C++ std::function 深度解析与实战指南

2. 成员函数与绑定

当需要调用类的成员函数时，std::function 结合 std::bind 能轻松处理对象上下文：

#include <iostream>
#include <functional>

class Worker {
public:
    void process(int x) {
        std::cout << "Processing: " << x << "\n";
    }
};

int main() {
    Worker w;
    // 绑定成员函数，_1 代表第一个占位符
    std::function<void(int)> cb = std::bind(&Worker::process, &w, std::placeholders::_1);
    cb(42); // 输出：Processing: 42
}

3. 捕获 Lambda 作为回调

Lambda 捕获外部变量后，非常适合用作闭包形式的回调：

#include <iostream>
#include <functional>

void doSomething(std::function<void(int)> callback) {
    for (int i = 0; i < 3; ++i) {
        callback(i);
    }
}

int main() {
    int count = 0;
    // 捕获局部变量 count
    doSomething([&count](int x) {
        count += x;
        std::cout << "Got: " << x << ", total: " << count << "\n";
    });
}

进阶实战场景

1. 轻量级线程池任务封装

在线程池中，我们需要将任意任务放入队列等待执行。std::function<void()> 是理想的载体：

#include <iostream>
#include <thread>
#include <queue>
#include <functional>
#include <mutex>
#include <condition_variable>
#include <vector>
#include <atomic>

class ThreadPool {
public:
    using Task = std::function<void()>;

    ThreadPool(size_t threadCount = std::thread::hardware_concurrency()) {
        running = true;
        for (size_t i = 0; i < threadCount; ++i) {
            workers.emplace_back([this]() {
                while (running) {
                    Task task;
                    {
                        std::unique_lock<std::mutex> lock(mutex);
                        cond.wait(lock, [this]() {
                            return !taskQueue.empty() || !running;
                        });
                        if (!running && taskQueue.empty()) return;
                        task = std::move(taskQueue.front());
                        taskQueue.pop();
                    }
                    task();
                }
            });
        }
    }

    ~ThreadPool() {
        running = false;
        cond.notify_all();
        for (auto& t : workers) {
            if (t.joinable()) t.join();
        }
    }

    void enqueue(Task task) {
        {
            std::lock_guard<std::mutex> lock(mutex);
            taskQueue.push(std::move(task));
        }
        cond.notify_one();
    }

private:
    std::vector<std::thread> workers;
    std::queue<Task> taskQueue;
    std::mutex mutex;
    std::condition_variable cond;
    std::atomic<bool> running;
};

// 使用示例
int main() {
    ThreadPool pool(4);
    for (int i = 0; i < 5; ++i) {
        pool.enqueue([i]() {
            std::this_thread::sleep_for(std::chrono::milliseconds(100));
            std::cout << "Task " << i << " done\n";
        });
    }
}

2. 事件广播系统（Observer 模式）

实现一个松耦合的事件中心，允许注册多个监听器：

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

class EventDispatcher {
public:
    using Listener = std::function<void(int)>;

    void addListener(const Listener& listener) {
        listeners.push_back(listener);
    }

    void broadcast(int eventCode) {
        for (auto& listener : listeners) {
            listener(eventCode);
        }
    }

private:
    std::vector<Listener> listeners;
};

int main() {
    EventDispatcher dispatcher;
    dispatcher.addListener([](int code) {
        std::cout << "Listener A received: " << code << "\n";
    });
    dispatcher.addListener([](int code) {
        std::cout << "Listener B processed: " << code * 2 << "\n";
    });
    dispatcher.broadcast(100);
}

3. 插件系统接口封装

利用 std::function 封装动态传入的行为实现，常用于插件架构：

#include <iostream>
#include <functional>
#include <memory>

class PluginInterface {
public:
    using Callback = std::function<void(const std::string&)>;

    void registerCallback(Callback cb) {
        onMessage = cb;
    }

    void emitMessage(const std::string& msg) {
        if (onMessage) onMessage(msg);
    }

private:
    Callback onMessage;
};

// 模拟插件
class MyPlugin {
public:
    void attachTo(PluginInterface& iface) {
        iface.registerCallback([this](const std::string& msg) {
            std::cout << "[MyPlugin] received: " << msg << "\n";
        });
    }
};

int main() {
    PluginInterface iface;
    MyPlugin plugin;
    plugin.attachTo(iface);
    iface.emitMessage("Hello from core system!");
}

最佳实践总结

• 性能敏感场景：如果调用对象固定且频繁，优先考虑函数指针或模板特化，避免 std::function 的类型擦除开销。
• 灵活性优先：需要支持 Lambda、状态对象或动态绑定时，std::function 是首选。
• 传参优化：尽量使用 const std::function<>& 引用传参，避免不必要的拷贝构造。
• 移动语义：对于频繁调用的回调，结合 std::move 可以减少资源转移成本。