C++如何使用std::function实现通用函数包装器

std::function是C++11引入的通用函数包装器，属于标准库functional头文件的内容，它可以存储、复制和调用任何可调用对象，只要这些对象的调用签名匹配std::function模板参数指定的类型。通过std::function，我们可以把不同类型的可调用对象统一管理，极大提升了代码的灵活性。

std::function的基本定义与初始化

std::function是一个模板类，使用时需要指定它包装的可调用对象的签名，格式为std::function<返回类型(参数类型列表)>。我们可以通过多种方式对std::function对象进行初始化，以下是常见的几种情况。

包装普通函数

普通函数的签名需要和std::function的模板参数匹配，直接赋值即可完成初始化。

#include <functional>
#include <iostream>

// 普通函数
int add(int a, int b) {
    return a + b;
}

int main() {
    // 定义std::function对象，包装返回int、接收两个int参数的可调用对象
    std::function<int(int, int)> func;
    // 初始化为普通函数add
    func = add;
    // 像普通函数一样调用
    std::cout << func(1, 2) << std::endl; // 输出3
    return 0;
}

包装lambda表达式

lambda表达式是C++中常用的可调用对象，同样可以直接赋值给匹配的std::function对象。

#include <functional>
#include <iostream>

int main() {
    std::function<int(int, int)> func;
    // 初始化为lambda表达式
    func = [](int a, int b) {
        return a * b;
    };
    std::cout << func(3, 4) << std::endl; // 输出12
    return 0;
}

包装函数对象

函数对象是重载了operator()的类实例，也可以被std::function包装。

#include <functional>
#include <iostream>

// 函数对象类
class Multiply {
public:
    int operator()(int a, int b) const {
        return a * b;
    }
};

int main() {
    std::function<int(int, int)> func;
    // 初始化为函数对象实例
    func = Multiply();
    std::cout << func(5, 6) << std::endl; // 输出30
    return 0;
}

包装类的成员函数

类的成员函数需要绑定对应的对象实例才能调用，因此初始化时需要结合std::bind或者lambda表达式完成绑定。

#include <functional>
#include <iostream>

class Calculator {
public:
    int sub(int a, int b) {
        return a - b;
    }
};

int main() {
    Calculator calc;
    std::function<int(int, int)> func;
    // 使用lambda绑定成员函数和对象实例
    func = [&calc](int a, int b) {
        return calc.sub(a, b);
    };
    std::cout << func(10, 3) << std::endl; // 输出7
    return 0;
}

std::function的常见使用场景

回调函数封装

在事件驱动或者异步编程中，经常需要传递回调函数，使用std::function可以统一回调函数的类型，让接口更通用。

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

// 事件处理器类型
using EventHandler = std::function<void(int)>;

class EventSystem {
private:
    std::vector<EventHandler> handlers;
public:
    void register_handler(EventHandler handler) {
        handlers.push_back(handler);
    }
    void trigger_event(int event_id) {
        for (auto& handler : handlers) {
            handler(event_id);
        }
    }
};

int main() {
    EventSystem sys;
    // 注册lambda作为回调
    sys.register_handler([](int id) {
        std::cout << "Event " << id << " triggered" << std::endl;
    });
    // 注册普通函数作为回调
    void (*func)(int) = [](int id) {
        std::cout << "Handle event " << id << std::endl;
    };
    sys.register_handler(func);
    sys.trigger_event(1);
    return 0;
}

容器存储不同类型可调用对象

std::function可以让容器统一存储不同类型的可调用对象，方便批量管理和调用。

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

int main() {
    std::vector<std::function<int(int)>> tasks;
    // 存入lambda
    tasks.push_back([](int x) { return x * 2; });
    // 存入普通函数
    int square(int x) { return x * x; }
    tasks.push_back(square);
    // 存入函数对象
    struct Double {
        int operator()(int x) const { return x + x; }
    };
    tasks.push_back(Double());
    for (auto& task : tasks) {
        std::cout << task(3) << std::endl; // 输出6、9、6
    }
    return 0;
}

使用std::function的注意事项

• std::function包装的可调用对象签名必须和模板参数完全匹配，否则会导致编译错误。
• 默认初始化的std::function对象不包含任何可调用对象，调用它会抛出std::bad_function_call异常，使用前需要检查是否为空，可以通过if (func)的方式判断。
• std::function的存储和调用会有一定的性能开销，在对性能要求极高的场景下需要谨慎使用。
• 包装成员函数时，需要注意绑定的对象生命周期，避免对象已经被销毁后还调用std::function导致未定义行为。

std::function是C++中非常实用的通用函数包装工具，合理使用它可以让代码更加灵活、接口更加通用，是进阶C++开发必须掌握的知识点之一。

std::functionC++函数包装器可调用对象修改时间：2026-07-20 11:27:30