C++模板实例化与特化顺序问题（含子类场景）

咱们先把这个问题拆明白，你遇到的specialization of ‘MyClass<B>::Cache’ after instantiation错误，核心是没搞清楚C++模板实例化的触发时机和特化的规则。

你以为只有写typedef MyClass<B> MyB;的时候才会用到MyClass<B>::Cache，但实际上C++编译器的规则更严格：当编译器需要确定MyClass<T>的内存布局时，就必须拿到嵌套类Cache的完整定义。而MyClass<T>里有mutable Cache _cache;这个非指针成员——编译器要知道_cache占多少字节，所以只要MyClass<T>被实例化（哪怕只是被声明为typedef），就会立刻触发Cache的实例化。

在你的原始代码里，MyClass<B>::Cache的特化写在了通用版MyClass<T>::Cache的定义之后，还在typedef MyClass<B> MyB;之后。当编译器处理到typedef MyClass<B> MyB;时，它会尝试实例化MyClass<B>，这时候找不到MyClass<B>::Cache的特化，就会去实例化通用版的MyClass<T>::Cache。等后面编译器看到你写的MyClass<B>::Cache特化时，通用版已经被实例化过了——C++明确禁止在模板成员被实例化之后再提供特化，所以就报了那个错。

要解决这个问题，关键是让MyClass<B>::Cache的特化出现在MyClass<B>被实例化之前。这里需要用到前置声明，把特化的存在提前告诉编译器，避免它误实例化通用版。下面是调整后的完整代码：

// 先前置声明基类和模板，让编译器知道MyClass的存在
class MyBase { public: virtual int value() = 0; };
template<class T> class MyClass;

// 前置声明MyClass<B>::Cache的特化，告诉编译器这个特化会在后面定义
class B;
template<> class MyClass<B>::Cache;

// 现在定义B类
class B { double value() { return 3.1415; } };

// 定义MyClass模板的主体
template<class T>
class MyClass : public MyBase {
protected:
    class Cache;
    mutable Cache _cache;
public:
    MyClass(T t) : _cache(t.value()) {};
    virtual int value() override;
};

// 定义通用版本的MyClass<T>::Cache
template<class T>
class MyClass<T>::Cache {
public:
    int x;
    // 给通用版加一个接受int的构造函数，匹配MyClass<T>的初始化
    Cache(int val) : x(val) {}
    int getVal(){return x;}
};

// 现在定义MyClass<B>::Cache的特化——这时候还没实例化MyClass<B>，完全合法
template<> class MyClass<B>::Cache {
public:
    double z;
    // 加一个接受double的构造函数，匹配MyClass<B>用B::value()初始化_cache的逻辑
    Cache(double val) : z(val) {}
    int getVal(){return 100*z;}
};

// 实现MyClass<T>::value()成员函数
template<class T>
int MyClass<T>::value() { return _cache.getVal(); }

// 最后定义A类并实例化模板
class A { int value() { return 42; } };
typedef MyClass<A> MyA;
typedef MyClass<B> MyB;

这里还有个容易忽略的细节：你的原始代码里，MyClass<T>的构造函数用t.value()初始化_cache，但通用版和特化版的Cache都没有对应的构造函数——通用版需要接受int的构造（匹配A::value()的返回值），特化版需要接受double的构造（匹配B::value()的返回值），否则编译会报构造函数不匹配的错误。

你提到把_cache改成指针就能解决，本质原因是：指针的大小是固定的（比如64位系统是8字节），编译器不需要知道Cache的完整定义就能声明指针成员。这时候MyClass<T>的实例化不会触发Cache的实例化，直到你实际调用_cache->getVal()的时候才会去实例化Cache，这时候你的特化已经定义好了，就不会报错。不过如果你不想用动态内存（比如new/delete或者智能指针），上面调整顺序的方案更干净。

• 对于模板类的非指针成员，编译器在实例化模板类时就需要知道成员的完整定义，因为要确定类的内存布局。
• 模板成员的特化必须出现在该成员被实例化之前，否则编译器会先实例化通用版本，后续的特化就会被判定为无效。

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