如何为模板特化的foo<T>类定义依赖特化函数的通用成员函数？

你遇到的核心问题是：让foo<T*>、foo<T&>这类特化类共享same_function的实现，同时该函数能调用各自特化版本的different_function。以下是两种可行的解决思路：

方案一：用CRTP（奇异递归模板模式）实现基类复用 #

CRTP可以让基类明确知道派生类的类型，从而安全调用派生类的成员函数。具体实现如下：

#include <iostream>

// 封装通用逻辑的CRTP基类
template <typename Derived>
struct foo_base {
    void same_function() const {
        std::cout << "the exact same function but now ";
        // 转换为派生类指针，调用其特化的different_function
        static_cast<const Derived*>(this)->different_function();
    }
};

template <class T>
struct foo;

// 指针特化类，继承对应版本的foo_base
template <class T>
struct foo<T*> : foo_base<foo<T*>> {
    void different_function() const { std::cout << "calling from T*\n"; }
};

// 引用特化类，继承对应版本的foo_base
template <class T>
struct foo<T&> : foo_base<foo<T&>> {
    void different_function() const { std::cout << "calling from T&\n"; }
};

int main() {
    foo<int*> a;
    a.different_function();
    a.same_function();
    foo<int&> b;
    b.different_function();
    b.same_function();
}

每个特化类只需继承foo_base<当前特化类>，就能自动获得same_function的实现，无需重复编写逻辑。基类通过static_cast将自身指针转换为派生类指针，从而调用派生类特化的different_function。

方案二：提取通用逻辑为独立模板函数 #

把same_function的通用代码抽成一个独立的模板函数，让每个特化类的same_function调用这个函数即可：

#include <iostream>

// 通用逻辑的模板函数，接受任意拥有different_function的类型
template <typename FooType>
void same_function_impl(const FooType& obj) {
    std::cout << "the exact same function but now ";
    obj.different_function();
}

template <class T>
struct foo;

template <class T>
struct foo<T*> {
    void different_function() const { std::cout << "calling from T*\n"; }
    void same_function() const {
        same_function_impl(*this);
    }
};

template <class T>
struct foo<T&> {
    void different_function() const { std::cout << "calling from T&\n"; }
    void same_function() const {
        same_function_impl(*this);
    }
};

int main() {
    foo<int*> a;
    a.different_function();
    a.same_function();
    foo<int&> b;
    b.different_function();
    b.same_function();
}

这种方式更轻量化，无需继承关系，只需在每个特化类的same_function中调用通用实现即可，适合逻辑简单的场景。

补充说明 #

你之前的两种尝试没成功的原因：

• 把方法放到主模板foo<T>中：主模板是未定义的，而foo<T*>、foo<T&>是独立的特化类型，主模板的成员无法直接被特化类复用。
• 普通基类方案：普通基类不知道派生类的具体类型，无法直接调用派生类特化的different_function，而CRTP正好解决了这个问题。

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