C++11 std::function 详解：通用多态函数包装器

template< class >
class function; /* 未定义的主模板 */

template< class R, class... Args >
class function<R(Args...)>; /* 特化版本 */

#include <functional>
#include <iostream>

void print_num(int i) {
    std::cout << i << '\n';
}

int main() {
    // 存储自由函数
    std::function<void(int)> f_display = print_num;
    f_display(-9);  // 输出: -9
}

// 存储lambda表达式
std::function<void()> f_display_42 = []() { print_num(42); };
f_display_42();  // 输出: 42

// 存储std::bind的结果
std::function<void()> f_display_31337 = std::bind(print_num, 31337);
f_display_31337();  // 输出: 31337

struct Foo {
    Foo(int num) : num_(num) {}
    void print_add(int i) const { std::cout << num_ + i << '\n'; }
    int num_;
};

// 存储成员函数
std::function<void(const Foo&, int)> f_add_display = &Foo::print_add;
const Foo foo(314159);
f_add_display(foo, 1);  // 输出: 314160

// 存储数据成员访问器
std::function<int(Foo const&)> f_num = &Foo::num_;
std::cout << "num_: " << f_num(foo) << '\n';  // 输出: num_: 314159

// 结合std::bind存储成员函数（绑定对象）
using std::placeholders::_1;
std::function<void(int)> f_add_display2 = std::bind(&Foo::print_add, foo, _1);
f_add_display2(2);  // 输出: 314161

// 结合std::bind存储成员函数（绑定对象指针）
std::function<void(int)> f_add_display3 = std::bind(&Foo::print_add, &foo, _1);
f_add_display3(3);  // 输出: 314162

struct PrintNum {
    void operator()(int i) const {
        std::cout << i << '\n';
    }
};

// 存储函数对象
std::function<void(int)> f_display_obj = PrintNum();
f_display_obj(18);  // 输出: 18

auto factorial = [](int n) {
    // 存储lambda对象以模拟"递归lambda"
    std::function<int(int)> fac = [&](int n) { 
        return (n < 2) ? 1 : n * fac(n - 1); 
    };
    return fac(n);
};

for (int i{5}; i != 8; ++i)
    std::cout << i << "! = " << factorial(i) << ";  ";
// 输出: 5! = 120;  6! = 720;  7! = 5040;

class Button {
public:
    using Callback = std::function<void()>;
    
    void set_on_click(Callback cb) {
        on_click_ = std::move(cb);
    }
    
    void click() const {
        if (on_click_) {  // 检查是否有回调
            on_click_();  // 调用回调
        }
    }
    
private:
    Callback on_click_;
};

// 使用示例
Button btn;
btn.set_on_click([]() { std::cout << "Button clicked!\n"; });
btn.click();  // 触发回调

#include <unordered_map>

enum class Operation { Add, Subtract, Multiply };

int main() {
    std::unordered_map<Operation, std::function<int(int, int)>> operations;
    
    operations[Operation::Add] = [](int a, int b) { return a + b; };
    operations[Operation::Subtract] = [](int a, int b) { return a - b; };
    operations[Operation::Multiply] = [](int a, int b) { return a * b; };
    
    std::cout << "3 + 4 = " << operations[Operation::Add](3, 4) << '\n';
    std::cout << "5 - 2 = " << operations[Operation::Subtract](5, 2) << '\n';
    std::cout << "2 * 6 = " << operations[Operation::Multiply](2, 6) << '\n';
}

// 伪代码示例
std::future<int> async_calculate(std::function<int()> func) {
    return std::async(std::launch::async, func);
}

// 使用
auto future = async_calculate([]() { 
    // 耗时计算
    return 42; 
});

// 注册完成回调（实际实现可能更复杂）

std::function<void()> f;
try {
    f();  // 空函数调用
} catch (const std::bad_function_call& e) {
    std::cout << "Error: " << e.what() << '\n';
}

if (f) {  // 等价于 if (f.operator bool())
    f();
}

// C++11中未定义行为，C++23中禁止
std::function<const int&()> F([] { return 42; }); 
int x = F();  // 未定义行为：引用绑定到临时对象

// 正确示例
std::function<int&()> G([]() -> int& { 
    static int i{42}; 
    return i; 
});

auto lambda = []() { /* ... */ };  // 精确类型
std::function<void()> func = lambda;  // 类型擦除，有开销