如何显式初始化接收自身类型作为模板参数的C++类？

你遇到的本质问题是C++静态类型系统的内存布局要求和TypeScript动态/引用语义的差异：

• TypeScript中对象都是堆上引用，泛型仅做类型标注，不会产生递归的内存需求；
• 但C++是静态类型语言，模板实例化时编译器必须计算出类型的确定内存大小。如果写Function<Function<...>>，这个类型的大小会是sizeof(std::vector<Function<...>>) + sizeof(std::string)，而内层的Function<...>又需要嵌套相同的结构，无限递归下去，编译器无法算出合法的内存大小，因此这种写法根本无法通过编译。

要实现「函数体包含其他Function实例」的需求，必须打破这种无限递归的类型依赖，常用方案有两种：

1. 基于抽象基类+智能指针的多态方案 #

通过抽象基类统一接口，用智能指针存储嵌套的Function实例，避免值语义带来的递归内存问题：

代码实现 #

// commons.h
#include <vector>
#include <string>
#include <memory>

// 抽象基类，定义Function通用接口
class FunctionBase {
public:
    virtual ~FunctionBase() = default;
    virtual void execute() const = 0; // 示例通用方法
    const std::string name;
protected:
    FunctionBase(std::string name) : name(std::move(name)) {}
};

// 模板子类，实现具体的函数体存储
template<class T>
class Function : public FunctionBase {
private:
    const std::vector<T> body;
public:
    Function(std::string name, std::vector<T> body)
        : FunctionBase(std::move(name)), body(std::move(body)) {}
    
    void execute() const override {
        // 此处实现具体执行逻辑
    }
};

显式实例化时，针对存储智能指针的类型即可：

// commons.cc
#include "commons.h"

template<typename T>
Function<T>::Function(std::string name, std::vector<T> body)
    : FunctionBase(std::move(name)), body(std::move(body)) {}

// 实例化存储FunctionBase智能指针的Function类型
template class Function<std::unique_ptr<FunctionBase>>;

此时Function<std::unique_ptr<FunctionBase>>的内存大小是确定的：std::vector的固定开销 + std::string的大小 + 基类成员，而std::unique_ptr本身只是一个指针大小，不会触发递归。

2. 基于std::variant的代数数据类型方案 #

如果不需要多态接口，可以用std::variant定义支持多种元素类型的集合，包含指向自身的智能指针：

代码实现 #

// commons.h
#include <vector>
#include <string>
#include <memory>
#include <variant>

// 前向声明
template<class T>
class Function;

// 定义可存储的元素类型：基础类型或Function的智能指针
using FuncElement = std::variant<int, double, std::unique_ptr<Function<FuncElement>>>;

template<class T>
class Function {
private:
    const std::vector<T> body;
    const std::string name;
public:
    Function(std::string name, std::vector<T> body)
        : name(std::move(name)), body(std::move(body)) {}
};

显式实例化直接针对FuncElement类型：

// commons.cc
#include "commons.h"

template<typename T>
Function<T>::Function(std::string name, std::vector<T> body)
    : name(std::move(name)), body(std::move(body)) {}

template class Function<FuncElement>;

这种方式更贴近函数式语言的代数数据类型设计，FuncElement可以灵活存储多种类型，包括嵌套的Function实例。

TypeScript的泛型系统之所以支持无限嵌套：

1. 所有对象都是堆上的引用，变量仅存储指针，不存在递归的内存布局需求；
2. 泛型仅作为编译期类型检查工具，运行时不会生成具体的类型实例，不需要计算内存大小。

而C++的模板是编译期代码生成工具，实例化时必须确定类型的完整内存布局，这是两者不可逾越的本质区别。

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