在派生实例化之前如何创建抽象类

Question

如何创建派生类并在创建派生类时实例化基类。

这样

template<class T> 
struct Base 
{
  typedef T type;
  static const int n = 3;
  virtual int f() = 0;
  int f(int x) { return x * 2; }
};

// doesn't compile!
template<class T> 
struct Derived : Base<T> 
{
    type field;         // The compiler doesn't know Base<T>::type yet!
    int f() { return n; } // the compiler doesn't know n yet, and f(int) is maksed!
};

Answer 1

您可以通过多种方式做到这一点，如果您希望派生类自然地使用基类，您可以尝试使用模板模板。

假设你有相同的基类，那么派生类应该是这样的：

template< class T, template<typename> class Base > 
struct Derived : Base<T> 
{
    typename Base<T>::type field; 
    int f() 
    {
      return n;
    }
    int f(int x)
    {
      return Base<T>::f(x);
    }
};

但是要实例化 Derived 类，您还需要指定 Base 类。

这样

Derived<int, Base> object; 

现在假设您不想这样做，您只想从 SAME 基类实例化 Derived 对象，那么您必须专门化派生模板。 p>

template< class T, template<typename> class Base = Base > 
struct Derived : Base<T> 
{
    Base<T>::type field; 
    int f() 
    {
       return n;
    }
    int f(int x)
    {
        return Base<T>::f(x);
    }
};

这样你现在可以创建Derived<int> 或Derived<string>

喜欢这个

int main()
{
    Derived<int> bs1;
    bs1.field = 200;
    std::cout << bs1.f() << std::endl;
    std::cout << bs1.f(50)<< std::endl;
    std::cout << bs1.field<< std::endl;

    Derived<std::string> bs2;
    bs2.field = "example";
    std::cout << bs2.f() << std::endl;
    std::cout << bs2.f(50)<< std::endl;
    std::cout << bs2.field<< std::endl;

    return 0;
}

什么时候应该这样做？

当您出于某种原因打算切换基类时，可能是针对测试用例。更改基类也可以更改上下文。

您还可以创建一个模板 typedef，它允许您将基本属性带入您自己的派生类。这是一个很好的方法。

Answer 2

您可以通过using 声明引入相关名称：

template<class T> 
struct Base 
{
  typedef T type;
  static const int n = 3;
  virtual int f() = 0;
  int f(int x) { return x * 2; }
};

template<class T> 
struct Derived : Base<T> 
{
    using typename Base<T>::type;
    using Base<T>::n;

    type field;
    int f() { return n; }
};

Live example

对于以这种方式继承的类型，您还必须使用typename 关键字（就像我在上面所做的那样），以便编译器知道名称指的是一个类型。有一个 question on SO 提供有关此要求的更多信息。

另一种方法是明确限定名称：使用typename Base<T>::type 代替type 和Base<T>::n 代替n。您选择哪种很大程度上取决于偏好。

Answer 3

在为某些类型 T 实例化 Derived 之前，编译器无法猜测 type 和 n 应该来自哪里。毕竟，在定义Derived 之后 为不同类型提供Base 的特化是合法的。

你需要改变的是：

template<class T> 
struct Derived : Base<T> 
{
    typename Base<T>::type field; // tell the compiler it's a type,
                                  // and where it comes from
    int f() { return Base<T>::n; }// tell the compiler where n comes from too
};

using 声明的工作方式相同，通过限定这些名称，如果您多次使用每个名称，它最终可能看起来更简洁。