类模板协变返回类型无效问题技术求助

C++的虚函数协变返回类型仅支持指针或引用类型，值类型（包括你定义的Template<T>这类模板实例化值）不满足协变规则。尽管Template<Derived>继承自Template<Base>，但返回值类型的派生关系无法触发协变逻辑，这就是编译器报错的核心原因。

方案1：改用指针作为协变返回类型 #

将clone方法的返回类型改为指针，利用C++原生的指针协变规则：

#include <memory>
#include <tr2/type_traits>
#include <string>

class Base;
class Derived;

template<typename T>
class Template : public Template<typename T::Parent> {};

template<>
class Template<Base> {};

class Base {
public:
  virtual std::string name() const { return "Node"; }
  // 基类返回基类模板指针
  virtual Template<Base>* clone() const = 0;
  virtual ~Base() = default;
};

class Derived : public Base {
public:
  using Parent = Base;

  std::string name() const { return "Token"; }
  // 派生类返回派生类模板指针，符合协变规则
  Template<Derived>* clone() const override { 
    return new Template<Derived>(); 
  }
};

template<typename T>
using base_t = typename std::tr2::bases<T>::type::first::type;

int main()
{
  auto base = Template<Base>();
  auto derived = Template<Derived>();
  base = Template<Derived>();
  static_assert(std::is_same_v<Template<Base>, base_t<Template<Derived>>>);
  
  Base* d = new Derived();
  Template<Base>* cloned = d->clone(); // 自动隐式转换为基类指针
  delete cloned;
  delete d;
}

方案2：针对AST项目的CRTP实现（更贴合智能指针需求） #

如果你希望保留智能指针的语义，避免手动管理内存，可以使用**奇异递归模板模式（CRTP）**绕过协变限制，同时提供类型安全的clone接口：

// 基类Node
class Node {
public:
  virtual ~Node() = default;
  // 多态接口，返回基类智能指针
  virtual Pointer<Node> clone() const = 0;
};

// CRTP模板，为派生类提供类型安全的clone方法
template<typename DerivedNode>
class CloneableNode : public Node {
public:
  // 类型安全的clone，返回派生类智能指针
  Pointer<DerivedNode> clone() const {
    return static_cast<const DerivedNode*>(this)->cloneImpl();
  }

  // 重写基类的虚方法，自动转换为基类指针返回
  Pointer<Node> clone() const override {
    return this->clone();
  }

protected:
  // 派生类需要实现的具体拷贝逻辑
  virtual Pointer<DerivedNode> cloneImpl() const = 0;
};

// 派生类Token示例
class Token : public CloneableNode<Token> {
protected:
  Pointer<Token> cloneImpl() const override {
    return Pointer<Token>::New(*this); // 调用Token的拷贝构造创建新实例
  }
};

这种方式下：

• 当你持有Pointer<Token>时，调用clone()直接得到Pointer<Token>
• 当你持有Pointer<Node>时，调用clone()得到Pointer<Node>，实际指向的是Token实例，可通过动态转换转回Pointer<Token>（如果需要）

内容的提问来源于stack exchange，提问作者lotkey