C++ 函数包装器

C++函数包装器

介绍

函数包装器（Function Wrapper）是C++标准模板库(STL)中的一个重要概念，它提供了一种通用的方式来存储、复制和调用各种可调用对象（如函数指针、成员函数指针、函数对象和lambda表达式）。在C++中，函数包装器主要通过std::function类模板实现。

函数包装器的主要作用是：

• 统一处理不同类型的可调用对象
• 实现回调机制
• 增强代码的灵活性和可维护性

基本语法

std::function的基本声明形式为：

#include <functional>

std::function<返回值类型(参数类型列表)> 包装器名称;

使用示例

包装普通函数

#include <iostream>
#include <functional>

int add(int a, int b) {
    return a + b;
}

int main() {
    std::function<int(int, int)> func = add;
    std::cout << "Result: " << func(3, 4) << std::endl;  // 输出: Result: 7
    return 0;
}

包装lambda表达式

#include <iostream>
#include <functional>

int main() {
    std::function<int(int, int)> func = [](int a, int b) {
        return a * b;
    };
    std::cout << "Result: " << func(5, 6) << std::endl;  // 输出: Result: 30
    return 0;
}

包装成员函数

#include <iostream>
#include <functional>

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

int main() {
    Calculator calc;
    std::function<int(Calculator&, int, int)> func = &Calculator::subtract;
    std::cout << "Result: " << func(calc, 10, 3) << std::endl;  // 输出: Result: 7
    return 0;
}

类型擦除

std::function实现了类型擦除技术，这意味着它可以存储任何符合签名的可调用对象，而不需要知道具体类型。这是通过模板特化和虚函数等技术实现的。

classDiagram class function { +operator()() -target -invoker } note for function "隐藏了实际可调用对象的类型"

实际应用场景

回调机制

函数包装器常用于实现回调机制，特别是在事件驱动编程中：

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

class Button {
    std::function<void()> onClick;
public:
    void setOnClick(std::function<void()> callback) {
        onClick = callback;
    }
    void click() {
        if (onClick) onClick();
    }
};

int main() {
    Button btn;
    btn.setOnClick([]() {
        std::cout << "Button clicked!" << std::endl;
    });
    btn.click();  // 输出: Button clicked!
    return 0;
}

策略模式

函数包装器可以简化策略模式的实现：

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

class Sorter {
    std::function<bool(int, int)> compare;
public:
    Sorter(std::function<bool(int, int)> comp) : compare(comp) {}
    
    void sort(std::vector<int>& data) {
        for (size_t i = 0; i < data.size(); ++i) {
            for (size_t j = i + 1; j < data.size(); ++j) {
                if (compare(data[i], data[j])) {
                    std::swap(data[i], data[j]);
                }
            }
        }
    }
};

int main() {
    std::vector<int> numbers = {5, 2, 8, 1, 9};
    
    // 升序排序
    Sorter ascending([](int a, int b) { return a > b; });
    ascending.sort(numbers);
    for (int n : numbers) std::cout << n << " ";  // 输出: 1 2 5 8 9
    std::cout << std::endl;
    
    // 降序排序
    Sorter descending([](int a, int b) { return a < b; });
    descending.sort(numbers);
    for (int n : numbers) std::cout << n << " ";  // 输出: 9 8 5 2 1
    std::cout << std::endl;
    
    return 0;
}

性能考虑

使用std::function会有一定的性能开销，主要包括：

• 动态内存分配（某些情况下）
• 间接函数调用
• 类型擦除带来的额外开销

在性能敏感的代码中，可以考虑直接使用函数指针或模板参数。

与函数指针的比较

特性	std::function	函数指针
可调用对象类型	支持函数、lambda、函数对象等	仅支持普通函数
捕获状态	可以	不可以
性能	较低	较高
灵活性	高	低

高级用法

绑定参数

可以结合std::bind使用，实现参数绑定：

#include <iostream>
#include <functional>

int multiply(int a, int b, int c) {
    return a * b * c;
}

int main() {
    using namespace std::placeholders;
    
    // 绑定第一个参数为2，第三个参数为3
    std::function<int(int)> func = std::bind(multiply, 2, _1, 3);
    std::cout << "Result: " << func(5) << std::endl;  // 输出: Result: 30 (2*5*3)
    return 0;
}

函数组合

可以创建高阶函数，实现函数组合：

#include <iostream>
#include <functional>

template <typename F, typename G>
auto compose(F f, G g) {
    return [=](auto x) { return f(g(x)); };
}

int main() {
    std::function<int(int)> square = [](int x) { return x * x; };
    std::function<int(int)> increment = [](int x) { return x + 1; };
    
    auto squareThenIncrement = compose(increment, square);
    std::cout << "Result: " << squareThenIncrement(3) << std::endl;  // 输出: 10 (3² + 1)
    
    return 0;
}

数学表示

从数学角度看，函数包装器可以表示为： $f:X\to Y$ 其中$X$是参数类型，$Y$是返回类型。

注意事项

• 检查std::function是否为空（使用operator bool）
• 注意生命周期问题，避免悬垂引用
• 在性能关键路径上谨慎使用

总结

std::function是C++中处理各种可调用对象的强大工具，它提供了统一的接口和极大的灵活性。虽然有一定的性能开销，但在大多数应用场景中，这种开销是可以接受的。理解并熟练使用函数包装器，可以显著提高C++代码的表达能力和可维护性。