1. 为什么需要std::function和std::bind在C98时代回调函数的实现主要依赖函数指针但函数指针存在严重局限性——它无法捕获上下文状态也无法处理成员函数和函数对象。假设我们要实现一个GUI按钮的点击事件处理// C98风格 - 使用裸函数指针 void onClick() { std::cout Button clicked\n; } class Button { void (*callback_)(); public: void setCallback(void (*func)()) { callback_ func; } void click() { if(callback_) callback_(); } }; // 使用限制 // 1. 无法使用带捕获的lambda // 2. 无法绑定成员函数 // 3. 无法使用函数对象(functor)C11引入的std::function和std::bind解决了这些问题。它们提供了类型擦除统一处理各种可调用对象状态保存支持捕获上下文接口适配调整参数数量和顺序2. std::function深度解析2.1 基本用法std::function是一个通用的函数包装器可以存储、复制和调用任何可调用目标。其模板声明为templateclass R, class... Args class functionR(Args...);典型使用场景#include functional #include iostream int add(int a, int b) { return a b; } struct Multiply { int operator()(int a, int b) const { return a * b; } }; int main() { std::functionint(int, int) func; // 存储普通函数 func add; std::cout func(3, 4) \n; // 输出7 // 存储函数对象 func Multiply(); std::cout func(3, 4) \n; // 输出12 // 存储lambda表达式 func [](int a, int b) { return a - b; }; std::cout func(3, 4) \n; // 输出-1 }2.2 实现原理剖析std::function的核心是类型擦除技术其典型实现包含三个关键部分调用器基类抽象接口具体调用器模板存储实际可调用对象小型对象优化避免小对象的堆分配简化版实现示意templatetypename class function; templatetypename R, typename... Args class functionR(Args...) { struct callable_base { virtual R operator()(Args...) 0; virtual ~callable_base() default; }; templatetypename F struct callable : callable_base { F f; callable(F f) : f(std::forwardF(f)) {} R operator()(Args... args) override { return f(std::forwardArgs(args)...); } }; std::unique_ptrcallable_base invoker; public: templatetypename F function(F f) : invoker(new callableF(std::forwardF(f))) {} R operator()(Args... args) const { return (*invoker)(std::forwardArgs(args)...); } };2.3 性能考量std::function的调用成本主要包括虚函数调用开销通常1-2个时钟周期可能的堆内存分配当存储对象较大时无法内联优化在性能敏感场景的优化建议优先使用模板参数传递可调用对象对小对象使用std::function的SBOSmall Buffer Optimization避免高频创建/销毁std::function对象3. std::bind完全指南3.1 基本绑定std::bind实现参数绑定和参数顺序调整#include functional #include iostream int add(int a, int b, int c) { return a b c; } int main() { using namespace std::placeholders; // 绑定第一个参数为10 auto add10 std::bind(add, 10, _1, _2); std::cout add10(20, 30) \n; // 输出60 // 调整参数顺序 auto rearrange std::bind(add, _2, _3, _1); std::cout rearrange(10, 20, 30) \n; // 输出60 }占位符_1、_2等表示调用时传入的第1、第2个参数。3.2 成员函数绑定绑定成员函数需要提供对象指针或引用struct Printer { void print(const std::string msg, int times) const { for(int i0; itimes; i) std::cout msg \n; } }; int main() { using namespace std::placeholders; Printer p; // 绑定成员函数 auto printFunc std::bind(Printer::print, p, _1, _2); printFunc(Hello, 3); // 绑定部分参数 auto printTwice std::bind(Printer::print, p, _1, 2); printTwice(World); }3.3 绑定与智能指针正确处理对象生命周期struct Service { void process(int value) { std::cout Processing: value \n; } }; int main() { auto svc std::make_sharedService(); // 安全绑定shared_ptr auto processor std::bind( Service::process, svc, // 复制shared_ptr增加引用计数 _1 ); processor(42); // 安全调用 }4. 现代C的最佳实践4.1 lambda vs std::bindC14后lambda通常比std::bind更可取// 传统bind方式 auto oldWay std::bind(add, 10, _1); // 现代lambda方式 auto newWay [](int b) { return add(10, b); };优势对比可读性更好编译器优化更友好支持完美转发调试更方便4.2 典型应用场景回调系统实现class EventDispatcher { std::unordered_mapstd::string, std::vectorstd::functionvoid() handlers; public: void on(const std::string event, std::functionvoid() handler) { handlers[event].push_back(handler); } void trigger(const std::string event) { for(auto h : handlers[event]) h(); } };线程池任务封装class ThreadPool { std::queuestd::functionvoid() tasks; public: templatetypename F, typename... Args void enqueue(F f, Args... args) { auto task std::bind( std::forwardF(f), std::forwardArgs(args)... ); tasks.push(std::functionvoid()(task)); } };5. 常见陷阱与解决方案5.1 悬空引用问题错误示例std::functionvoid() createCallback() { int local 42; return [](){ std::cout local; }; // 危险 } // local被销毁正确做法std::functionvoid() createCallback() { return [val42](){ std::cout val; }; // 值捕获 }5.2 重载函数处理处理重载函数需要明确类型void process(int) {} void process(double) {} int main() { // 错误无法确定选择哪个重载 // auto f std::bind(process, _1); // 正确显式指定类型 auto f std::bind( static_castvoid(*)(int)(process), _1 ); }5.3 性能优化技巧避免频繁创建std::function对象对小对象使用inline存储考虑使用function_ref(C23)等轻量级替代方案// 模拟function_ref的简单实现 templatetypename F class function_ref; templatetypename R, typename... Args class function_refR(Args...) { void* obj_; R (*invoker_)(void*, Args...); public: templatetypename F function_ref(F f) : obj_(const_castvoid*(static_castconst void*(f))), invoker_([](void* obj, Args... args) { return (*static_castF*(obj))( std::forwardArgs(args)...); }) {} R operator()(Args... args) const { return invoker_(obj_, std::forwardArgs(args)...); } };6. 实际工程案例6.1 实现Observer模式class Observer { public: virtual void update(int) 0; }; class Subject { std::vectorstd::functionvoid(int) observers; public: void addObserver(std::functionvoid(int) obs) { observers.push_back(obs); } void notify(int value) { for(auto obs : observers) obs(value); } }; // 使用示例 struct ConsoleLogger { void log(int v) { std::cout Value: v \n; } }; int main() { Subject sub; ConsoleLogger logger; // 绑定成员函数 sub.addObserver( std::bind(ConsoleLogger::log, logger, _1) ); // 使用lambda sub.addObserver([](int v) { std::cout Lambda: v \n; }); sub.notify(42); }6.2 命令模式实现class Command { std::functionvoid() action; public: templatetypename F Command(F f) : action(std::forwardF(f)) {} void execute() { if(action) action(); } }; int main() { std::vectorCommand commands; // 添加各种命令 commands.emplace_back([](){ std::cout Command 1\n; }); int value 0; commands.emplace_back([value](){ std::cout Increment: value \n; }); // 执行所有命令 for(auto cmd : commands) cmd.execute(); }7. 进阶话题7.1 结合可变参数模板templatetypename... Args class Signal { std::vectorstd::functionvoid(Args...) slots; public: templatetypename F void connect(F f) { slots.emplace_back(std::forwardF(f)); } void emit(Args... args) { for(auto slot : slots) slot(args...); } }; int main() { Signalint, std::string signal; signal.connect([](int x, const std::string s) { std::cout x : s \n; }); signal.emit(42, Answer); }7.2 实现函数组合templatetypename F, typename G auto compose(F f, G g) { return [](auto... args) { return f(g(args...)); }; } int main() { auto add [](int a, int b) { return a b; }; auto square [](int x) { return x * x; }; auto func compose(square, add); std::cout func(3, 4) \n; // 输出49 }7.3 类型擦除的替代方案对于性能敏感场景可以考虑使用variant-based方案templatetypename... Fs struct Overload : Fs... { using Fs::operator()...; }; templatetypename... Fs Overload(Fs...) - OverloadFs...; class AnyCallable { std::variant std::functionvoid(int), std::functionvoid(double) func; public: templatetypename F AnyCallable(F f) { if constexpr(std::is_invocable_vF, int) { func std::functionvoid(int)(std::forwardF(f)); } else { func std::functionvoid(double)(std::forwardF(f)); } } void operator()(auto arg) { std::visit([arg](auto f) { if constexpr(std::is_invocable_vdecltype(f), decltype(arg)) { f(arg); } }, func); } };