能否为模板类成员设置回调？非模板类调用模板类成员可行吗？

完全没问题，你要做的就是把模板类的成员函数“传递”给非模板类的对象，让它能在需要的时候调用。核心是用类型擦除来绕过模板参数的限制——毕竟非模板类不知道你模板类的具体参数嘛。下面给你两种最常用的实现方式，附代码示例：

方式一：用std::function做类型擦除（最简洁） #

这种方式用标准库的std::function封装回调，不用额外写基类，代码量少，上手快。

首先定义你的非模板类，它持有一个std::function成员来存储回调：

#include <functional>
#include <iostream>

// 非模板类
class NonTemplateClass {
public:
    // 设置回调函数
    void setCallback(std::function<void()> callback) {
        callback_ = std::move(callback);
    }

    // 触发回调的成员函数
    void triggerCallback() {
        if (callback_) {
            callback_(); // 调用模板类的成员函数
        }
    }

private:
    std::function<void()> callback_;
};

然后是你的模板类，在构造的时候把自己的成员函数绑定到非模板对象的回调上：

// 模板类
template <typename T>
class TemplateClass {
public:
    TemplateClass() {
        // 用lambda绑定当前实例的成员函数，传给非模板对象（推荐写法）
        non_template_obj_.setCallback([this]() {
            this->templateMemberFunc();
        });
        // 也可以用std::bind实现：
        // non_template_obj_.setCallback(std::bind(&TemplateClass<T>::templateMemberFunc, this));
    }

    // 让非模板对象调用的模板类成员函数
    void templateMemberFunc() {
        std::cout << "Template class member function called! Type: " << typeid(T).name() << std::endl;
    }

    // 暴露非模板对象的触发方法，方便测试
    void triggerNonTemplateCallback() {
        non_template_obj_.triggerCallback();
    }

private:
    NonTemplateClass non_template_obj_;
};

测试代码：

int main() {
    TemplateClass<int> int_template;
    int_template.triggerNonTemplateCallback(); // 输出对应类型的回调信息

    TemplateClass<std::string> str_template;
    str_template.triggerNonTemplateCallback();

    return 0;
}

方式二：用抽象基类实现多态（更灵活/低开销） #

如果你不想用std::function的运行时开销，可以用多态的方式：定义一个抽象基类作为回调接口，模板类继承这个基类并实现接口，非模板类持有基类指针。

首先定义抽象回调接口：

// 抽象回调基类（非模板）
class CallbackInterface {
public:
    virtual ~CallbackInterface() = default;
    virtual void invoke() = 0; // 纯虚函数，定义回调签名
};

然后非模板类持有这个基类的指针：

class NonTemplateClass {
public:
    void setCallback(CallbackInterface* callback) {
        callback_ = callback;
    }

    void triggerCallback() {
        if (callback_) {
            callback_->invoke();
        }
    }

private:
    CallbackInterface* callback_ = nullptr;
};

模板类继承并实现接口：

template <typename T>
class TemplateClass : public CallbackInterface {
public:
    TemplateClass() {
        non_template_obj_.setCallback(this); // 把自己作为回调传给非模板对象
    }

    void templateMemberFunc() {
        std::cout << "Template class member function called! Type: " << typeid(T).name() << std::endl;
    }

    // 实现抽象接口，转发到模板类成员函数
    void invoke() override {
        templateMemberFunc();
    }

    void triggerNonTemplateCallback() {
        non_template_obj_.triggerCallback();
    }

private:
    NonTemplateClass non_template_obj_;
};

测试代码和方式一完全一致，效果也相同。

关键注意事项 #

• 生命周期管理：不管用哪种方式，都要确保模板类实例的生命周期比非模板对象长——不然非模板对象持有的回调会变成悬空指针/引用，导致未定义行为。如果需要更安全的管理，可以考虑用std::shared_ptr配合std::weak_ptr（比如在std::function里捕获weak_from_this()）。
• 回调签名自定义：上面的例子用的是无参无返回的回调，你可以根据实际需求修改std::function的签名或者抽象基类的纯虚函数签名（比如带参数、有返回值）。

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