我正在努力将模板编程(以及在未来的某个时间点，模板元编程)应用到现实世界的场景中。我发现的一个问题是 C++ 模板和多态性并不总是以我想要的方式一起使用。

我的问题是我尝试应用模板编程的方式是否不正确(我应该使用普通的旧 OOP)，或者我是否仍然停留在 OOP 思维模式中。

在这种特殊情况下，我正在尝试使用策略模式来解决问题。我一直遇到这样的问题，我最终想要一些模板似乎不支持的多态行为。

使用组合的 OOP 代码:

class Interpolator {
   public:
     Interpolator(ICacheStrategy* const c, IDataSource* const d);
     Value GetValue(const double);
}

void main(...) {
    Interpolator* i;
    if(param==1)
       i = new Interpolator(new InMemoryStrategy(...), new TextFileDataSource(...));
    else if(param==2)
       i = new Interpolator(new InMemoryStrategy(...), new OdbcDataSource(...));
    else if(param==3)
       i = new Interpolator(new NoCachingStrategy(...), new RestDataSource(...));

    while(run) {
       double input = WaitForRequest();
       SendRequest( i->GetValue(input));
    }
}

潜在的模板版本:

class Interpolator<class TCacheStrategy, class TDataSource> {
   public:
     Interpolator();
     Value GetValue(const double);               //may not be the best way but
     void ConfigCache(const& ConfigObject);      //just to illustrate Cache/DS         
     void ConfigDataSource(const& ConfigObject); //need to configured

}

//Possible way of doing main?
void main(...) {
    if(param==1)
       DoIt(Interpolator<InMemoryStrategy,TextFileDataSource>(),c,d);
    else if(param==2)
       DoIt(Interpolator<InMemoryStrategy,OdbcDataSource>(),c,d)
    else if(param==3)
       DoIt(Interpolator<NoCachingStrategy,RestDataSource>(),c,d)

}

template<class T>
void DoIt(const T&  t, ConfigObject c, ConfigObject d) {
   t.ConfigCache(c);
   t.ConfigDataSource(c);
   while(run) {
      double input = WaitForRequest();
      SendRequest( t.GetValue(input));
   }
}

当我尝试将 OOP 实现转换为基于模板的实现时，可以轻松翻译 Interpolator 代码。基本上，用模板类型参数替换“接口(interface)”，并添加一种机制来传递策略/数据源的实例或配置参数。

但是当我谈到“主要”时，我不清楚应该如何编写以利用模板元编程风格的模板。我经常想使用多态，但它似乎不能很好地与模板一起使用(有时，感觉就像我需要 Java 的类型删除泛型......呃)。

当我经常发现我想做的事情是 TemplateType<?,?> x = new TemplateType<X,Y>()其中 x 不在乎 X,Y 是什么。

其实这是我在使用模板时经常遇到的问题。

1. 我是否需要再申请一级 模板？
2. 我是否正在尝试使用我 Shiny 的新电源模板 Spanner 将 OOP 钉安装到 PCI 插槽中？
3. 或者我只是在想这一切 模板错了 编程？

[编辑] 一些人指出这实际上不是模板元编程，所以我稍微改写了这个问题。也许这就是问题的一部分——我还没有弄清楚 TMP 到底是什么。

最佳答案

模板提供静态多态性:您在编译时指定模板参数来实现策略。它们不提供动态多态性，您在运行时为对象提供实现策略的虚拟成员函数。

您的示例模板代码将创建三个不同的类，每个类都包含所有插值器代码，使用不同的模板参数进行编译，并可能从它们内联代码。从代码大小的 POV 来看，这可能不是您想要的，尽管它绝对没有错。假设您正在优化以避免函数调用开销，那么它可能是对动态多态性的改进。更有可能是矫枉过正。如果您想动态使用策略模式，则不需要模板，只需在相关的地方进行虚拟调用。

您不能有 MyTemplate<?> 类型的变量(除非在实例化之前出现在另一个模板中)。 MyTemplate<X>和 MyTemplate<Y>是完全不相关的类(即使 X 和 Y 是相关的)，如果它们是从同一个模板实例化的，它们可能恰好具有相似的功能(它们不必是 - 一个可能是专门化的)。即使它们是，如果模板参数涉及任何成员函数的签名，那么这些函数也不相同，它们只是具有相同的名称。所以从动态多态的观点来看，同一个模板的实例与任何两个类都处于相同的位置——只有给它们一个带有一些虚成员函数的公共(public)基类，它们才能发挥作用。

所以，你可以定义一个通用的基类:

class InterpolatorInterface {
public:
    virtual Value GetValue(const double) = 0;
    virtual void ConfigCache(const& ConfigObject) = 0;
    virtual void ConfigDataSource(const& ConfigObject) = 0;
    virtual ~InterpolatorInterface() {}
};

然后:

template <typename TCacheStrategy, typename TDataSource>
class Interpolator: public InterpolatorInterface {
    ...
};

现在您正在使用模板根据编译时已知的内容创建不同类型的插值器(因此从插值器到策略的调用是非虚拟的)，并且您正在使用动态多态性对它们进行相同处理即使您直到运行时才知道您想要哪一个(因此从客户端到插值器的调用是虚拟的)。您只需要记住，这两种技术几乎是完全独立的技术，而使用每种技术的决定几乎没有关系。

顺便说一句，这不是模板元编程，它只是使用模板。

编辑。至于什么是 TMP，下面是典型的介绍性示例:

#include <iostream>

template<int N>
struct Factorial {
    static const int value = N*Factorial<N-1>::value;
};

template<>
struct Factorial<0> {
    static const int value = 1;
};

int main() {
    std::cout << "12! = " << Factorial<12>::value << "\n";
}

注意那 12 个!已由编译器计算，并且是编译时常量。这是令人兴奋的，因为事实证明 C++ 模板系统是图灵完备的编程语言，而 C 预处理器不是。受限于资源限制，您可以在编译时进行任意计算，避免在编译时知道输入的情况下的运行时开销。模板可以像函数式语言一样操作其模板参数，模板参数可以是整数或类型。或函数，尽管在编译时不能“调用”这些函数。或其他模板，尽管它们不能作为结构的静态成员“返回”。

关于c++ - 模板多态可以代替OO多态吗？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/1213366/