引言
在C++11之前，处理不同类型的可调用对象（函数指针、仿函数等）时，我们需要为每种类型编写特定的代码，这给代码的通用性和可维护性带来了挑战。C++11引入了std::function和std::bind这两个强大的工具，极大地简化了可调用对象的管理和使用。
一、std::function：统一的函数包装器
1.1 基本概念
std::function是一个类模板，定义在<functional>头文件中，它可以包装存储各种可调用对象，包括：
普通函数指针
仿函数（函数对象）
Lambda表达式
成员函数指针
bind表达式
1.2 基本用法
#include <functional> #include <iostream> int add(int a, int b) { return a + b; } struct Multiply { int operator()(int a, int b) { return a * b; } }; int main() { // 包装普通函数 std::function<int(int, int)> f1 = add; // 包装仿函数 std::function<int(int, int)> f2 = Multiply(); // 包装lambda表达式 std::function<int(int, int)> f3 = [](int a, int b) { return a - b; }; std::cout << f1(10, 5) << std::endl; // 输出15 std::cout << f2(10, 5) << std::endl; // 输出50 std::cout << f3(10, 5) << std::endl; // 输出5 return 0; }1.3 包装成员函数
包装成员函数时需要特别注意，因为成员函数有隐含的this指针参数：
class Calculator { public: static int static_add(int a, int b) { return a + b; } int instance_multiply(int a, int b) { return a * b * factor; } private: int factor = 2; }; int main() { // 包装静态成员函数 std::function<int(int, int)> f4 = &Calculator::static_add; // 包装普通成员函数 Calculator calc; std::function<int(Calculator*, int, int)> f5 = &Calculator::instance_multiply; std::function<int(Calculator, int, int)> f6 = &Calculator::instance_multiply; std::cout << f4(10, 5) << std::endl; // 输出15 std::cout << f5(&calc, 10, 5) << std::endl; // 输出100 std::cout << f6(calc, 10, 5) << std::endl; // 输出100 return 0; }1.4 实际应用案例：逆波兰表达式求值
#include <vector> #include <string> #include <stack> #include <functional> #include <map> class Solution { public: int evalRPN(std::vector<std::string>& tokens) { std::stack<int> st; // 使用map映射运算符和对应的操作函数 std::map<std::string, std::function<int(int, int)>> opFuncMap = { {"+", [](int x, int y) { return x + y; }}, {"-", [](int x, int y) { return x - y; }}, {"*", [](int x, int y) { return x * y; }}, {"/", [](int x, int y) { return x / y; }} }; for (auto& str : tokens) { if (opFuncMap.find(str) != opFuncMap.end()) { int right = st.top(); st.pop(); int left = st.top(); st.pop(); st.push(opFuncMap[str](left, right)); } else { st.push(std::stoi(str)); } } return st.top(); } };这种实现方式的优势在于易于扩展，新增运算符只需在map中添加对应条目即可。
二、std::bind：参数绑定和适配器
2.1 基本概念
std::bind是一个函数模板，它可以绑定函数的部分参数，生成新的可调用对象。这对于参数适配和函数组合非常有用。
2.2 基本用法
#include <functional> #include <iostream> int multiply(int a, int b, int c) { return a * b * c; } int main() { using namespace std::placeholders; // 用于_1, _2等占位符 // 绑定所有参数 auto bound1 = std::bind(multiply, 2, 3, 4); std::cout << bound1() << std::endl; // 输出24 // 使用占位符调整参数顺序 auto bound2 = std::bind(multiply, _2, _1, 10); std::cout << bound2(3, 4) << std::endl; // 相当于multiply(4, 3, 10) // 绑定部分参数 auto bound3 = std::bind(multiply, 5, _1, _2); std::cout << bound3(2, 3) << std::endl; // 相当于multiply(5, 2, 3) return 0; }2.3 与成员函数结合使用
class FinancialCalculator { public: double calculateInterest(double principal, double rate, int years) { double amount = principal; for (int i = 0; i < years; ++i) { amount *= (1 + rate); } return amount - principal; } }; int main() { using namespace std::placeholders; FinancialCalculator calculator; // 绑定成员函数和对象 auto boundFunc = std::bind(&FinancialCalculator::calculateInterest, &calculator, _1, _2, _3); // 创建特定利率的计算器 auto fixedRateCalculator = std::bind(&FinancialCalculator::calculateInterest, &calculator, _1, 0.05, _2); std::cout << boundFunc(10000, 0.03, 5) << std::endl; std::cout << fixedRateCalculator(10000, 5) << std::endl; return 0; }2.4 实际应用：金融计算器
#include <functional> #include <iostream> // 计算复利的lambda表达式 auto compoundInterest = [](double rate, double principal, int years) -> double { double amount = principal; for (int i = 0; i < years; ++i) { amount *= (1 + rate); } return amount - principal; }; int main() { using namespace std::placeholders; // 创建不同利率策略的计算器 auto threeYear_1_5 = std::bind(compoundInterest, 0.015, _1, 3); auto fiveYear_1_5 = std::bind(compoundInterest, 0.015, _1, 5); auto tenYear_2_5 = std::bind(compoundInterest, 0.025, _1, 10); double investment = 100000; std::cout << "3年期1.5%利率收益: " << threeYear_1_5(investment) << std::endl; std::cout << "5年期1.5%利率收益: " << fiveYear_1_5(investment) << std::endl; std::cout << "10年期2.5%利率收益: " << tenYear_2_5(investment) << std::endl; return 0; }三、function与bind的组合使用
3.1 创建灵活的回调系统
#include <functional> #include <vector> #include <iostream> class EventManager { private: std::vector<std::function<void(int)>> handlers; public: void registerHandler(std::function<void(int)> handler) { handlers.push_back(handler); } void triggerEvent(int value) { for (auto& handler : handlers) { handler(value); } } }; void logger(const std::string& prefix, int value) { std::cout << prefix << ": " << value << std::endl; } class Processor { public: void process(int data) { std::cout << "Processing: " << data * 2 << std::endl; } }; int main() { using namespace std::placeholders; EventManager manager; // 注册不同的处理器 manager.registerHandler([](int x) { std::cout << "Lambda handler: " << x << std::endl; }); manager.registerHandler(std::bind(logger, "Event", _1)); Processor processor; manager.registerHandler(std::bind(&Processor::process, &processor, _1)); // 触发事件 manager.triggerEvent(42); manager.triggerEvent(100); return 0; }3.2 实现策略模式
#include <functional> #include <vector> #include <algorithm> class SortingStrategy { public: using CompareFunction = std::function<bool(int, int)>; static bool ascending(int a, int b) { return a < b; } static bool descending(int a, int b) { return a > b; } static CompareFunction customStrategy(int threshold) { return [threshold](int a, int b) { // 自定义排序逻辑 if (a < threshold && b < threshold) return a < b; if (a >= threshold && b >= threshold) return a > b; return a < b; // 小于阈值的排在前面 }; } }; void sortVector(std::vector<int>& vec, SortingStrategy::CompareFunction comp) { std::sort(vec.begin(), vec.end(), comp); } int main() { std::vector<int> data = {5, 2, 8, 1, 9, 3}; // 使用不同的排序策略 sortVector(data, SortingStrategy::ascending); // 数据变为: 1, 2, 3, 5, 8, 9 sortVector(data, SortingStrategy::descending); // 数据变为: 9, 8, 5, 3, 2, 1 sortVector(data, SortingStrategy::customStrategy(5)); // 自定义排序逻辑 return 0; }四、性能考虑和最佳实践
4.1 性能特点
std::function有一定的性能开销，主要来自于类型擦除和动态分配在性能敏感的代码中，可以考虑使用模板或函数指针
std::bind也会引入一定的运行时开销
4.2 最佳实践
优先使用lambda表达式：相比
std::bind，lambda表达式通常更清晰、性能更好避免过度使用：在简单场景下，直接使用函数调用可能更合适
注意生命周期：绑定的对象要确保在调用时仍然有效
使用auto：接收
std::bind和lambda结果时使用auto关键字
// 推荐：使用lambda auto add5 = [](int x) { return x + 5; }; // 不推荐：使用bind（除非有特定需求） auto add5_bind = std::bind(std::plus<int>{}, _1, 5);五、总结
C++11的std::function和std::bind为函数式编程风格提供了强大的支持。它们使得代码更加灵活和可复用，特别是在需要处理多种可调用对象或进行参数绑定的场景中。
std::function提供了统一的类型接口，使得不同类型的可调用对象可以以一致的方式使用。而std::bind则提供了强大的参数绑定能力，可以创建新的函数对象。
在实际开发中，要根据具体需求选择合适的工具，并注意相关的性能影响和最佳实践。这两个工具的正确使用可以显著提高代码的质量和可维护性。
通过本文的介绍和示例，希望读者能够掌握function和bind的核心概念和实用技巧，在实际项目中灵活运用这些强大的C++11特性。
