函数对象与 std::function

class Adder {
    int base_;
public:
    Adder(int base) : base_(base) {}
    int operator()(int x) const { return base_ + x; }
};

Adder add5(5);
add5(10);  // 返回 15——带状态的计算

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>

struct Student {
    std::string name;
    int id;
    double gpa;
};

// 按 GPA 比较（降序）
struct CompareByGPA {
    explicit CompareByGPA(bool ascending = false)
        : ascending_(ascending) {}

    bool operator()(const Student& a, const Student& b) const {
        return ascending_ ? a.gpa < b.gpa : a.gpa > b.gpa;
    }

private:
    bool ascending_;  // 状态：升序还是降序
};

// 按 ID 比较
struct CompareByID {
    bool operator()(const Student& a, const Student& b) const {
        return a.id < b.id;
    }
};

// 通用排序函数：通过模板参数接收任何可调用对象
template <typename Comparator>
void sort_students(std::vector<Student>& students, Comparator cmp) {
    std::sort(students.begin(), students.end(), cmp);
}

// 使用 std::function 的版本：运行时选择比较器
void sort_students_runtime(std::vector<Student>& students,
                           std::function<bool(const Student&, const Student&)> cmp) {
    std::sort(students.begin(), students.end(), cmp);
}

int main() {
    std::vector<Student> students = {
        {"张三", 1003, 3.8},
        {"李四", 1001, 3.5},
        {"王五", 1002, 4.0}
    };

    // ---- 模板版本：编译期多态，零开销 ----
    std::cout << "===== 按 GPA 降序（函数对象） =====" << std::endl;
    sort_students(students, CompareByGPA(false));
    for (const auto& s : students) {
        std::cout << s.name << " | GPA " << s.gpa << std::endl;
    }

    std::cout << "\n===== 按 GPA 升序 =====" << std::endl;
    sort_students(students, CompareByGPA(true));
    for (const auto& s : students) {
        std::cout << s.name << " | GPA " << s.gpa << std::endl;
    }

    // ---- std::function 版本：运行期多态 ----
    std::cout << "\n===== std::function 统一接口 =====" << std::endl;

    std::function<bool(const Student&, const Student&)> comparator;

    // 可以存 Lambda
    comparator = [](const Student& a, const Student& b) {
        return a.id < b.id;
    };
    sort_students_runtime(students, comparator);
    std::cout << "按 ID: ";
    for (const auto& s : students) std::cout << s.id << " ";
    std::cout << std::endl;

    // 可以存函数对象
    comparator = CompareByGPA(true);
    sort_students_runtime(students, comparator);
    std::cout << "按 GPA 升序: ";
    for (const auto& s : students) std::cout << s.name << " ";
    std::cout << std::endl;

    // 查询 std::function 是否有效
    std::function<void()> empty_func;
    if (!empty_func) {
        std::cout << "\nstd::function 可以为空（类似空指针）" << std::endl;
    }

    return 0;
}

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

class EventManager {
public:
    using Callback = std::function<void()>;

    void on(const std::string& event, Callback cb) {
        callbacks_[event].push_back(std::move(cb));
    }

    void trigger(const std::string& event) {
        auto it = callbacks_.find(event);
        if (it != callbacks_.end()) {
            for (auto& cb : it->second) {
                cb();
            }
        }
    }

private:
    std::map<std::string, std::vector<Callback>> callbacks_;
};

// 不同签名的处理函数
void free_handler() {
    std::cout << "  [普通函数] 事件已处理" << std::endl;
}

void param_handler(int id, const std::string& msg) {
    std::cout << "  [参数函数] ID=" << id << ", MSG=" << msg << std::endl;
}

class SystemMonitor {
public:
    void on_startup(int code) {
        std::cout << "  [成员函数] 启动码: " << code << std::endl;
    }
};

int main() {
    EventManager em;
    SystemMonitor monitor;

    // 注册方式 1：Lambda（最灵活）
    em.on("startup", []() {
        std::cout << "  [Lambda] 系统初始化..." << std::endl;
    });

    // 注册方式 2：普通函数
    em.on("startup", free_handler);

    // 注册方式 3：用 std::bind 适配参数函数
    // param_handler 有参数，但 Callback 签名是 void()
    em.on("startup", std::bind(param_handler, 100, "数据库就绪"));
    em.on("startup", std::bind(param_handler, 200, "网络就绪"));

    // 注册方式 4：用 std::bind 绑定成员函数
    // monitor.on_startup(int) → void()
    em.on("startup", std::bind(&SystemMonitor::on_startup, &monitor, 0));

    // Lambda 替代 bind（更清晰的写法）
    em.on("startup", [&monitor]() {
        monitor.on_startup(999);
    });

    std::cout << "===== 触发 startup 事件 =====" << std::endl;
    em.trigger("startup");

    return 0;
}