Question

我不确定如何用英语说这个，但我想做这样的事情：

template <class T>
class derived: public T
{ blah };

基本上，我有一个模板类，但是我从模板中指定的类中派生出一个新类？即所以我不一定在编译时知道这个类。

这甚至可能吗？
如果是这样，那么它的语义是什么？

例如，假设我正在尝试编写“父”类。出于这个例子的目的，让我们说它是一个树父。树父本身是一棵树（因此它继承自树），但也有一个对子树的引用向量。
但是，父类本身不必是树;它可以是任何类，这样我可以写出类似的东西：

Parent<tree> treeParent;
Parent<shrub> shrubParent;

Answer 1

是。这是可能的。试着这样做。

我不一定在编译时知道这个类。

我想，你的意思是“在定义课程模板时，我不一定知道课程。”

编译时，您已经定义了类模板，并在代码中使用它，将模板参数传递给它，这意味着您在编译时就知道了类（即模板参数）。如果您不知道要用作base的类，那么您甚至无法编译代码。

Answer 2

这确实可以用于policy based design：

就像这个令人难以置信的人为例：

template<typename OutputPolicy>
struct Writer : public OutputPolicy {
  using OutputPolicy::print;
  void write(const std::string&) {
    //do some formatting etc.
    print(string);
  }
};

class StdoutPolicy {
public:
  set_linebreaks(const std::string&);
protected:
  void print(const std::string&);
};

政策中的公共方法可通过Writer访问。这样，策略可以使用其他方法修饰它所使用的类。

Answer 3

是的，这是可能的。这种语义与类模板中模板参数的任何其他使用的语义没有区别。您可以拥有类型为T的成员，类型为T的函数参数，也可以将T作为基类。这并不特别。

Answer 4

像这样：

#include <iostream>
using namespace std;

template<typename T>class classTemplateBase
{
    public:
       T value;
       classTemplateBase(T i)
       {
          this->value = i;
       }
       void test()
       {
          cout << value << endl;
       }
};

class classTemplateChild : public classTemplateBase<char>
{
    public:
       classTemplateChild( ): classTemplateBase<char>( 0 )  // default char is NUL
       {
          ;
       }

       classTemplateChild(char c): classTemplateBase<char>( c )
       {
          ;
       }
       void test2()
       {
          test();
       }
};

int main()
 {
      classTemplateBase <int> a( 42 );
      classTemplateChild b( 'A' );

      a.test();   // should print "42"
      b.test();   // should print "A"
      b.test2();  // should print "A"

  return 0;
 }

Answer 5

这是可能的，它也很常见并且已经得到了它自己的名字：奇怪的重复出现的模板模式。请参阅Wikipeida entry on Curiously recurring template pattern。

C ++：我可以编写一个派生自T的模板类吗？

5 个答案: