class MyClass {
public:
    void memberFunc(int x) { ... }
    // 實際被編譯器處理為：void memberFunc(MyClass* this, int x)
};

#include <iostream>

// 定義C風格回調函數(shù)類型
typedef void (*EventCallback)(int data, void* userData);

class FileProcessor {
private:
    std::string filename_;
public:
    FileProcessor(std::string name) : filename_(name) {}
    
    // 實際處理邏輯（非靜態(tài)成員函數(shù)）
    void process(int progress) {
        std::cout << "處理文件 [" << filename_ << "]：" << progress << "% 完成" << std::endl;
    }
    
    // 靜態(tài)成員函數(shù)：作為回調的中間層
    static void staticCallback(int progress, void* userData) {
        // 將void*轉換為類實例指針
        FileProcessor* self = static_cast<FileProcessor*>(userData);
        if (self) {
            self->process(progress);  // 調用非靜態(tài)成員函數(shù)
        }
    }
};

// 模擬第三方庫函數(shù)（接收C風格回調）
void simulateTask(EventCallback callback, void* userData) {
    for (int i = 0; i <= 100; i += 20) {
        callback(i, userData);  // 觸發(fā)回調
        // 模擬處理延遲
        std::this_thread::sleep_for(std::chrono::milliseconds(500));
    }
}

int main() {
    FileProcessor processor("data.txt");
    
    // 傳遞靜態(tài)成員函數(shù)和實例指針
    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) {}
    
    // 溫度更新處理（非靜態(tài)成員函數(shù)）
    void onTemperatureUpdate(double temp) {
        lastTemp_ = temp;
        std::cout << "[" << location_ << "] 溫度更新：" << temp 
                  << "°C（上次：" << lastTemp_ << "°C）" << std::endl;
    }
};

// 溫度監(jiān)控系統(tǒng)：接收回調并觸發(fā)更新
class TempMonitor {
private:
    DataCallback callback_;
public:
    // 注冊回調函數(shù)
    void setCallback(DataCallback callback) {
        callback_ = callback;
    }
    
    // 模擬溫度變化并觸發(fā)回調
    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綁定成員函數(shù)與實例
    // 格式：&類名::成員函數(shù), 實例指針, 參數(shù)占位符
    auto sensorCallback = std::bind(
        &TemperatureSensor::onTemperatureUpdate, 
        &sensor,                  // 綁定到的實例
        std::placeholders::_1     // 占位符：表示回調的第一個參數(shù)
    );
    
    // 注冊回調
    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);  // 觸發(fā)回調
        }
    }
};

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);  // 調用當前實例的成員函數(shù)
            });
        }
    }
};

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;
    // 按引用捕獲臨時對象（函數(shù)返回后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 << "計數(shù)器：" << counter_ << std::endl;
    }
};