C++类成员函数作为回调函数的实现与实践

class MyClass {
public:
    void memberFunc(int x) { ... }
    // 实际被编译器处理为：void memberFunc(MyClass* this, int x)
};

#include <iostream>

// 定义C风格回调函数类型
typedef void (*EventCallback)(int data, void* userData);

class FileProcessor {
private:
    std::string filename_;
public:
    FileProcessor(std::string name) : filename_(name) {}
    
    // 实际处理逻辑（非静态成员函数）
    void process(int progress) {
        std::cout << "处理文件 [" << filename_ << "]：" << progress << "% 完成" << std::endl;
    }
    
    // 静态成员函数：作为回调的中间层
    static void staticCallback(int progress, void* userData) {
        // 将void*转换为类实例指针
        FileProcessor* self = static_cast<FileProcessor*>(userData);
        if (self) {
            self->process(progress);  // 调用非静态成员函数
        }
    }
};

// 模拟第三方库函数（接收C风格回调）
void simulateTask(EventCallback callback, void* userData) {
    for (int i = 0; i <= 100; i += 20) {
        callback(i, userData);  // 触发回调
        // 模拟处理延迟
        std::this_thread::sleep_for(std::chrono::milliseconds(500));
    }
}

int main() {
    FileProcessor processor("data.txt");
    
    // 传递静态成员函数和实例指针
    simulateTask(FileProcessor::staticCallback, &processor);
    return 0;
}

#include <iostream>
#include <functional>  // 包含std::function和std::bind

// 定义回调类型：使用std::function包装可调用对象
using DataCallback = std::function<void(double)>;

class TemperatureSensor {
private:
    std::string location_;
    double lastTemp_ = 0.0;
public:
    TemperatureSensor(std::string loc) : location_(loc) {}
    
    // 温度更新处理（非静态成员函数）
    void onTemperatureUpdate(double temp) {
        lastTemp_ = temp;
        std::cout << "[" << location_ << "] 温度更新：" << temp 
                  << "°C（上次：" << lastTemp_ << "°C）" << std::endl;
    }
};

// 温度监控系统：接收回调并触发更新
class TempMonitor {
private:
    DataCallback callback_;
public:
    // 注册回调函数
    void setCallback(DataCallback callback) {
        callback_ = callback;
    }
    
    // 模拟温度变化并触发回调
    void simulateChanges() {
        double temps[] = {23.5, 24.1, 23.9, 24.3};
        for (double t : temps) {
            if (callback_) {
                callback_(t);  // 调用回调
            }
        }
    }
};

int main() {
    TemperatureSensor sensor("客厅");
    TempMonitor monitor;
    
    // 使用std::bind绑定成员函数与实例
    // 格式：&类名::成员函数, 实例指针, 参数占位符
    auto sensorCallback = std::bind(
        &TemperatureSensor::onTemperatureUpdate, 
        &sensor,                  // 绑定到的实例
        std::placeholders::_1     // 占位符：表示回调的第一个参数
    );
    
    // 注册回调
    monitor.setCallback(sensorCallback);
    // 模拟温度变化
    monitor.simulateChanges();
    
    return 0;
}

#include <iostream>
#include <functional>
#include <vector>

// 定义事件回调类型
using ClickCallback = std::function<void(int, int)>;

class Button {
private:
    ClickCallback onClick_;
    std::string label_;
public:
    Button(std::string label) : label_(label) {}
    
    // 设置点击回调
    void setOnClick(ClickCallback callback) {
        onClick_ = callback;
    }
    
    // 模拟点击事件
    void simulateClick(int x, int y) {
        std::cout << "按钮 [" << label_ << "] 被点击，坐标：(" << x << "," << y << ")" << std::endl;
        if (onClick_) {
            onClick_(x, y);  // 触发回调
        }
    }
};

class UIHandler {
public:
    void logClick(int x, int y) {
        std::cout << "记录点击位置：(" << x << "," << y << ")" << std::endl;
    }
    
    void registerButtons(std::vector<Button>& buttons) {
        // 为每个按钮注册点击回调（Lambda捕获当前实例）
        for (auto& btn : buttons) {
            btn.setOnClick([this](int x, int y) {  // 捕获this指针
                this->logClick(x, y);  // 调用当前实例的成员函数
            });
        }
    }
};

int main() {
    UIHandler handler;
    std::vector<Button> buttons = {Button("确定"), Button("取消")};
    
    // 注册回调
    handler.registerButtons(buttons);
    
    // 模拟点击
    buttons[0].simulateClick(100, 200);
    buttons[1].simulateClick(150, 200);
    
    return 0;
}

// 危险示例：捕获即将销毁的临时实例
std::function<void()> createDangerousCallback() {
    UIHandler tempHandler;
    // 按引用捕获临时对象（函数返回后tempHandler将销毁）
    return [&tempHandler]() {
        tempHandler.logClick(0, 0);  // 访问已销毁对象，未定义行为
    };
}

#include <mutex>

class ThreadSafeHandler {
private:
    std::mutex mtx_;  // 互斥锁保护共享资源
    int counter_ = 0;
public:
    void increment() {
        std::lock_guard<std::mutex> lock(mtx_);  // 自动加锁/解锁
        counter_++;
        std::cout << "计数器：" << counter_ << std::endl;
    }
};