#include <functional>

// 声明一个可以装“接受两个int、返回int”的可调用对象的盒子
std::function<int(int,int)> myBox;

// 1. 装一个 Lambda
myBox = [](int a, int b) { return a + b; };
int result = myBox(3, 4);      // 调用这个 Lambda，result = 7

// 2. 装一个普通函数
int multiplyFunc(int x, int y) { return x * y; }
myBox = multiplyFunc;          // 注意：普通函数名会自动转换成函数指针
result = myBox(5, 6);          // 30

// 3. 装一个仿函数（重载了 operator() 的类对象）
struct Multiplier {
    int operator()(int a, int b) { return a * b * 2; }
};
myBox = Multiplier();
result = myBox(2, 3);          // 12

#include <functional>
using namespace std::placeholders;   // 方便使用 _1, _2, ...

auto newFunc = std::bind(原始函数, 固定值或占位符, ...);

#include <iostream>
#include <functional>
using namespace std::placeholders;

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

int main() {
    // 固定 a=10, b=20, c 由调用时提供
    auto add10_and_20 = std::bind(add, 10, 20, _1);
    std::cout << add10_and_20(5) << std::endl;   // 10+20+5 = 35

    // 固定 a=1, c=100, b 占位
    auto add1_and_100 = std::bind(add, 1, _1, 100);
    std::cout << add1_and_100(50) << std::endl;  // 1+50+100 = 151

    return 0;
}

// 假设有个函数: void show(string name, int score)
void show(string name, int score) {
    cout << name << " 考了 " << score << " 分" << endl;
}

// 我们想创建一个新函数，交换参数顺序：先给分数，再给名字
auto show_reversed = std::bind(show, _2, _1);
show_reversed(95, "小明");   // 输出: 小明 考了 95 分

struct Student {
    void printScore(int score) {
        cout << "分数: " << score << endl;
    }
};

Student stu;
// 绑定成员函数，第一个固定参数是对象指针 &stu，第二个参数留作占位
auto printStuScore = std::bind(&Student::printScore, &stu, _1);
printStuScore(88);   // 调用 stu.printScore(88)

int x = 10;
auto addToX = std::bind([](int& a, int b) { a += b; }, std::ref(x), _1);
addToX(5);
std::cout << x;   // 15  (x 被成功修改)

#include <vector>
#include <algorithm>
// 找第一个小于5的数
vector<int> nums = {1, 5, 8, 12, 3};
auto it = std::find_if(nums.begin(), nums.end(),
                       std::bind(std::greater<int>(), 5, _1));
// 等价于: 5 > x，即 x < 5

#include <functional>
#include <vector>
#include <iostream>
using namespace std::placeholders;

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

int main() {
    // 定义一个存储“接受一个int，返回int”的盒子的容器
    std::vector<std::function<int(int)>> tasks;

    // 放入绑定了第一个参数为5的add
    tasks.push_back(std::bind(add, 5, _1));   // 等价于 add(5, ?)

    // 放入绑定了第一个参数为10的add
    tasks.push_back(std::bind(add, 10, _1));

    // 循环执行所有任务
    for (auto& task : tasks) {
        std::cout << task(3) << " ";   // 第一个输出 8，第二个输出 13
    }
    return 0;
}

#include <iostream>
#include <functional>   // std::function, std::bind, std::ref
#include <vector>
#include <algorithm>    // std::find_if, std::for_each
#include <string>
using namespace std;
using namespace std::placeholders;  // _1, _2 等占位符

// 普通函数
int multiply(int a, int b) {
    return a * b;
}

// 类：计算器
class Calculator {
public:
    int divide(int a, int b) const {   // 成员函数
        return a / b;
    }
    static int subtract(int a, int b) { // 静态成员函数
        return a - b;
    }
};

int main() {
    // ========== 1. std::function 基础 ==========
    cout << "=== std::function 基本使用 ===" << endl;

    // 装 Lambda 的盒子
    std::function<int(int,int)> box = [](int x, int y) { return x + y; };
    cout << "box(3,4) = " << box(3,4) << endl;              // 7

    // 装普通函数
    box = multiply;
    cout << "box(6,7) = " << box(6,7) << endl;              // 42

    // 装仿函数
    struct Doubler {
        int operator()(int a, int b) { return (a + b) * 2; }
    };
    box = Doubler();
    cout << "box(10,20) = " << box(10,20) << endl;          // 60

    // 把各种盒子装到一个容器里（回调列表）
    vector<std::function<int(int,int)>> callbacks;
    callbacks.push_back([](int a, int b) { return a * b; });
    callbacks.push_back(multiply);
    callbacks.push_back([](int a, int b) { return a + b + 1; });
    for (auto& cb : callbacks) {
        cout << "回调结果: " << cb(2, 3) << " ";            // 6 6 6
    }
    cout << endl;

    // ========== 2. std::bind 基础 ==========
    cout << "\n=== std::bind 基本使用 ===" << endl;

    // 固定第一个参数为2的乘函数：multiply(2, ?)
    auto doubleIt = bind(multiply, 2, _1);
    cout << "doubleIt(5) = " << doubleIt(5) << endl;        // 10

    // 固定第二个参数为10的乘函数：multiply(?, 10)
    auto timesTen = bind(multiply, _1, 10);
    cout << "timesTen(7) = " << timesTen(7) << endl;        // 70

    // 重排参数顺序：multiply(b, a)
    auto reversed = bind(multiply, _2, _1);
    cout << "reversed(3,4) = " << reversed(3,4) << endl;    // multiply(4,3)=12

    // 绑定成员函数（需要对象指针）
    Calculator calc;
    std::function<int(int,int)> divideFunc = bind(&Calculator::divide, &calc, _1, _2);
    cout << "divideFunc(10,3) = " << divideFunc(10,3) << endl; // 3

    // 绑定静态成员函数（无需对象）
    std::function<int(int,int)> subFunc = bind(&Calculator::subtract, _1, _2);
    cout << "subFunc(10,3) = " << subFunc(10,3) << endl;     // 7

    // 引用绑定：修改外部变量
    int x = 100;
    auto addToRef = bind([](int &a, int b) { a += b; }, ref(x), _1);
    addToRef(50);
    cout << "x 被修改为: " << x << endl;                    // 150

    // ========== 3. 在STL算法中使用bind（固定二元谓词）==========
    cout << "\n=== bind 在算法中的应用 ===" << endl;
    vector<int> nums = {1, 5, 8, 12, 3};

    // 找第一个小于5的元素：greater<int>()(5, x) 等价于 5 > x
    auto it = find_if(nums.begin(), nums.end(),
                      bind(greater<int>(), 5, _1));
    if (it != nums.end()) {
        cout << "第一个小于5的元素是: " << *it << endl;      // 1
    }

    // 更简单的写法：用Lambda（推荐）
    auto it2 = find_if(nums.begin(), nums.end(),
                       [](int x) { return x < 5; });
    // 结果一样

    // ========== 4. 结合使用：回调注册系统 ==========
    cout << "\n=== 回调系统示例 ===" << endl;

    class Button {
    public:
        // 注册点击回调
        void setOnClick(std::function<void()> callback) {
            onClickCallback = callback;
        }
        // 模拟点击
        void click() {
            if (onClickCallback) {
                onClickCallback();
            }
        }
    private:
        std::function<void()> onClickCallback;
    };

    Button button;
    int clickCount = 0;   // 记录点击次数
    // 注册一个Lambda作为回调（捕获点击次数变量引用）
    button.setOnClick([&clickCount]() {
        clickCount++;
        cout << "按钮被点击，总次数: " << clickCount << endl;
    });
    // 模拟三次点击
    button.click();   // 输出1
    button.click();   // 输出2
    button.click();   // 输出3

    return 0;
}

from functools import partial
from typing import Callable, List

def multiply(a, b):
    return a * b

class Calculator:
    def divide(self, a, b):
        return a // b
    @staticmethod
    def subtract(a, b):
        return a - b

# 1. 类似 std::function：直接赋值
func1: Callable[[int, int], int] = lambda x, y: x + y
print("func1(3,4) =", func1(3, 4))   # 7

# 容器存储回调
callbacks: List[Callable[[int, int], int]] = []
callbacks.append(lambda a, b: a * b)
callbacks.append(multiply)
for cb in callbacks:
    print("回调结果:", cb(2, 3))      # 6 6

# 2. 类似 std::bind：partial
double_it = partial(multiply, 2)       # 固定第一个参数
print("double_it(5) =", double_it(5)) # 10

# 不能重排参数，但可以用 lambda 代替
reversed_func = lambda a, b: multiply(b, a)
print("reversed(3,4) =", reversed_func(3,4))  # 12

# 绑定成员函数
calc = Calculator()
divide_func = lambda a, b: calc.divide(a, b)
print("divide_func(10,3) =", divide_func(10,3))  # 3

# 静态成员直接引用
sub_func = Calculator.subtract
print("sub_func(10,3) =", sub_func(10,3))  # 7

# 引用绑定：Python 的闭包本身就是引用，无需特殊语法
x = [100]   # 用列表模拟可变
def add_to(n):
    x[0] += n
capture_ref = partial(add_to, 50)  # 注意：这里partial绑定了函数，但函数内部修改的是外部列表
capture_ref()
print("x 修改后:", x[0])  # 150

# 3. 算法中使用固定参数
nums = [1, 5, 8, 12, 3]
it = next((x for x in nums if x < 5), None)
print("第一个小于5的元素是:", it)   # 1

# 4. 回调系统
class Button:
    def __init__(self):
        self.callback = None
    def on_click(self, callback):
        self.callback = callback
    def click(self):
        if self.callback:
            self.callback()

button = Button()
click_count = 0
def on_click_cb():
    nonlocal click_count
    click_count += 1
    print("点击次数:", click_count)
button.on_click(on_click_cb)
button.click()   # 1
button.click()   # 2