函数对象与可调用对象

可调用对象 = 捕获的状态 + operator()（或等价的调用方式）

函数指针：        状态 = 无；        调用 = 间接寻址
仿函数（类）：    状态 = 成员变量；  调用 = operator()，类型内联可见
lambda：         状态 = 捕获成员；  调用 = 编译器生成的匿名仿函数
std::function：  状态 = 任意（类型擦除）；调用 = 一次间接层
成员函数指针：    状态 = 对象引用；  调用 = (.*) / (->*)

bool cmp_desc(int a, int b) { return a > b; }

std::sort(v.begin(), v.end(), cmp_desc);        // 函数名隐式转指针
std::sort(v.begin(), v.end(), &cmp_desc);       // 等价显式写法

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

// 加法器仿函数：构造时绑定偏移量，operator() 应用它
class Add {
public:
    explicit Add(int v) : value_(v) {}
    int operator()(int x) const { return x + value_; }   // const：不修改捕获的状态
private:
    int value_;
};

// 比较器仿函数：降序
class CompareDesc {
public:
    bool operator()(int a, int b) const { return a > b; }
};

int main() {
    std::vector<int> vec{1, 2, 3, 4, 5};

    std::transform(vec.begin(), vec.end(), vec.begin(), Add(10));
    // vec: 11 12 13 14 15 —— Add(10) 是对象，被按值传入算法，逐元素调用

    std::sort(vec.begin(), vec.end(), CompareDesc());
    // vec: 15 14 13 12 11
}

int threshold = 100;
auto is_big = [threshold](int x) { return x > threshold; };  // 编译器生成：
// class __lambda_1 {
//     int threshold;                                   // 按值捕获 = 成员
// public:
//     bool operator()(int x) const { return x > threshold; }
// };

#include <functional>
#include <map>
#include <string>

using Handler = std::function<void(const std::string&)>;

std::map<std::string, Handler> handlers;             // 同一个 map 存不同类型的可调用对象
handlers["click"] = [](const std::string& s) { /* ... */ };
handlers["key"]   = MyFunctor{42};                   // 仿函数也能装
handlers["quit"]  = &quit_function;                  // 函数指针也能装

// 算法参数：模板——零开销
template <typename Pred>
void filter(std::vector<int>& v, Pred p);            // 谓词类型编译期已知，必然内联

// 接口边界：std::function——灵活性
void set_on_complete(std::function<void()> cb);      // 调用方传什么都行

#include <functional>
#include <iostream>

struct Server {
    void on_message(const std::string& msg) { std::cout << msg << '\n'; }
};

int main() {
    Server s;
    void (Server::*mp)(const std::string&) = &Server::on_message;
    (s.*mp)("hello");                                // 调用语法特殊：必须绑定对象

    // 更常用的现代写法：成员函数包成 lambda 或用 mem_fn
    auto cb = [&s](const std::string& msg) { s.on_message(msg); };
    cb("hello");
    std::mem_fn(&Server::on_message)(s, "hello");    // 统一调用形式
}

#include <algorithm>
#include <chrono>
#include <functional>
#include <iostream>
#include <vector>

bool cmp_fnptr(int a, int b) { return a > b; }       // 写法 1：函数指针

struct CmpFunctor {                                  // 写法 2：仿函数
    bool operator()(int a, int b) const { return a > b; }
};

int main() {
    std::vector<int> base(1'000'000);
    for (auto& x : base) x = static_cast<int>(rand());

    auto bench = [](const char* name, auto do_sort) {
        std::vector<int> v = base;
        auto t0 = std::chrono::steady_clock::now();
        do_sort(v);
        auto t1 = std::chrono::steady_clock::now();
        std::cout << name << ": "
                  << std::chrono::duration_cast<std::chrono::milliseconds>(t1 - t0).count()
                  << " ms\n";
    };

    bench("function ptr ", [](std::vector<int>& v) { std::sort(v.begin(), v.end(), cmp_fnptr); });
    bench("functor       ", [](std::vector<int>& v) { std::sort(v.begin(), v.end(), CmpFunctor{}); });
    bench("lambda        ", [](std::vector<int>& v) { std::sort(v.begin(), v.end(), [](int a, int b) { return a > b; }); });
    bench("std::function ", [](std::vector<int>& v) {
        std::function<bool(int,int)> f = cmp_fnptr;
        std::sort(v.begin(), v.end(), f);            // 谨慎：类型擦除进热路径
    });
}

#include <queue>
#include <string>
#include <vector>

struct Task {
    int priority;
    std::string name;
};

// 大顶堆默认取「最大」；任务系统想要「优先级数值最小者先出」
struct TaskEarlier {
    bool operator()(const Task& a, const Task& b) const {
        return a.priority > b.priority;      // 返回 true 表示 a 的优先级「低」于 b
    }
};

std::priority_queue<Task, std::vector<Task>, TaskEarlier> ready;
ready.push({5, "gc"});
ready.push({1, "heartbeat"});
// ready.top() 是 heartbeat：比较器为真时 a 排在 b 后面

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

class Button {
public:
    using Handler = std::function<void()>;      // 回调类型：零参最常见
    void add_handler(Handler h) { handlers_.push_back(std::move(h)); }
    void click() {
        for (auto& h : handlers_) h();          // 逐个触发
    }
private:
    std::vector<Handler> handlers_;
};

class Panel {                                    // 观察者：生命周期长于注册行为
public:
    explicit Panel(std::string name) : name_(std::move(name)) {}
    void flash() { std::cout << "panel " << name_ << " flashed\n"; }
private:
    std::string name_;
};

int main() {
    Button btn;
    auto panel = std::make_shared<Panel>("main");

    btn.add_handler([panel] { panel->flash(); });   // 按值捕获 shared_ptr：
                                                     // 回调表持有强引用，panel 保证存活
    btn.click();

    // 若 Panel 可能先于 Button 死亡，改持弱引用：
    std::weak_ptr<Panel> weak = panel;
    btn.add_handler([weak] {
        if (auto p = weak.lock()) p->flash();       // 还活着才回调
        else std::cout << "panel gone, skip\n";
    });
    btn.click();

    panel.reset();                                  // Panel 销毁
    btn.click();                                    // 第二个回调安全跳过
}

std::sort(v.begin(), v.end(), std::greater<int>{});   // 降序，替代手写 cmp
std::transform(a.begin(), a.end(), b.begin(), out.begin(), std::plus<int>{});
std::accumulate(v.begin(), v.end(), 1, std::multiplies<int>{});