C++ 模板、多态性和模板协方差

Question

我有一个看起来像这样的“包装”模板：

template <typename T>
class Wrapper {
  virtual T* get() = 0;
}

那么我有以下继承方案：

class A {
  // things
}

class B : public A {
  // more things
}

我有另一个使用该包装器的类：

class Worker {
  void work(Wrapper<A>* wa){
    A* a = wa->get();
    //do stuff with a.
  }
}

所有可以用A* 完成的事情，都可以用B* 完成，但我不能将Wrapper<B>* 作为Wrapper<A>* 传递给Worker。有没有办法允许这样做？

我已经阅读了有关 C++ 概念的信息，但我不知道它们如何解决问题。

Answer 1

如果每个类都报告其基类：

class A {
  using Base = void;
  // things
}

class B : public A {
  using Base = A;
  // more things
}

你可以的

template<typename T>
class Wrapper : public EmptyForVoid<T::Base>::Type

并使用EmptyForVoid 进行基类选择：

template<typename T>
struct EmptyForVoid { using Type = T; };

template<>
struct EmptyForVoid<void> { struct Type {}; };

这将使Wrappers 遵循与它们包装的类型相同的继承树。

Answer 2

你不能直接这样做，因为 C++ 没有协方差。在默认情况下方法不是虚拟的 C++ 中（与 Java 不同，我猜是 C#），尚不清楚这是否是一个很棒的想法（并且语言已经非常复杂）。基本上你需要做的是在work 上有一个薄的模板包装器：

class Worker {
public:
  template <class T>
  void work(Wrapper<T>* wa){
    work_on_a(wa->get());
  }
private:
  void work_on_a(A* a) { // do stuff with a}
}

这仍然是安全的，因为它仅在包装类型从 A 派生或以其他方式定义到 A 的隐式转换时才会编译，否则对 work_on_a 的函数调用将失败。

您可以在这里做更复杂的事情，但有各种优点和缺点，但这会使代码尽可能简单，并最大限度地减少模板膨胀。

虽然请注意，如果work 也需要是虚拟的，这将不起作用（因为虚拟函数不能是模板），而且事情会变得很快。

另一种方法是争论包装器根本不应该传递给work；如果您需要做的只是指向A 的指针，那么这就是您应该传入的全部内容。但取决于您的真实代码，这可能不是一个选项，或者没有意义。

Answer 3

来点Curiously Recurring Template Pattern怎么样：

class SubBase {
    virtual T* get() { /* default impl. */ }
};

template <typename T>
class Base : public SubBase {};

template <typename T>
class Wrapper : public Base<T> {
    virtual T* get() = 0;
}

…我不知道你的继承图是什么样的，但只要你包装的 T 类型没有 get() 方法，这应该可以工作。

---

编辑：正如已经指出的那样，这个简单的 sn-p 不起作用，也不是真正的 CRTP；我只能在fairly significant modification 之后做一个这样的例子。