如何在C++中实现类似Java的可重写异步监听函数？

这种需求是可行的，但C++需要借助虚函数多态或者函数对象来实现，和Java的重写逻辑思路类似，但语法细节不同。

方式一：类似Java的虚函数重写实现 #

要让子类的自定义Run函数在基类启动的线程中执行，核心是把基类的Run声明为虚函数，这样C++的动态绑定机制会自动调用子类的重写实现。

基类Listener实现 #

#include <thread>
#include <atomic>

class Listener {
private:
    std::thread listener_thread;
    std::atomic<bool> running{true}; // 线程退出控制标记

public:
    // 析构函数必须处理线程退出，避免资源泄漏
    virtual ~Listener() {
        running = false;
        if (listener_thread.joinable()) {
            listener_thread.join();
        }
    }

    // 启动监听线程
    void Start() {
        // 线程绑定当前对象的Run函数
        listener_thread = std::thread(&Listener::Run, this);
    }

    // 声明为虚函数，允许子类重写
    virtual void Run() {
        // 默认监听逻辑：循环等待/处理事件
        while (running) {
            // 基础处理代码，比如轮询、等待信号等
        }
    }
};

子类重写Run函数 #

// 自定义监听逻辑的子类
class CustomListener : public Listener {
public:
    // 用override关键字确保正确重写虚函数（C++11及以上支持）
    void Run() override {
        // 自定义逻辑，会在Listener启动的独立线程中执行
        while (true) {
            // 你的自定义处理代码
        }
    }
};

使用示例 #

int main() {
    CustomListener my_listener;
    my_listener.Start(); // 启动线程，执行CustomListener::Run

    // 主线程的其他业务逻辑...

    return 0;
}

方式二：更灵活的函数对象（无需子类化） #

如果不想通过继承实现，C++可以用std::function传递自定义逻辑，这种方式更灵活，不需要创建子类。

改进后的Listener类 #

#include <thread>
#include <atomic>
#include <functional>

class Listener {
private:
    std::thread listener_thread;
    std::atomic<bool> running{true};
    std::function<void()> custom_task; // 存储自定义逻辑

public:
    // 构造时传入自定义逻辑
    Listener(std::function<void()> task) : custom_task(std::move(task)) {}

    ~Listener() {
        running = false;
        if (listener_thread.joinable()) {
            listener_thread.join();
        }
    }

    void Start() {
        listener_thread = std::thread([this]() {
            while (running) {
                if (custom_task) {
                    custom_task(); // 执行自定义逻辑
                }
                // 可添加默认的监听基础逻辑
            }
        });
    }
};

使用示例 #

int main() {
    // 直接传入lambda作为自定义逻辑
    Listener my_listener([]() {
        // 这里写要在监听线程中执行的代码
    });
    my_listener.Start();

    // 主线程其他逻辑...

    return 0;
}

关键注意事项 #

• 虚函数必须显式声明virtual，否则子类的Run不会覆盖基类函数，线程会执行基类的默认实现。
• 线程退出必须妥善处理：用原子变量控制循环，析构时join线程，避免程序崩溃或资源泄漏。
• 以上代码需要C11及更高版本的编译器支持（std::thread、std::atomic、override等特性都是C11引入的）。

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