// File1.cpp
int globalVar = 10;           // 全局变量，外部链接
static int staticGlobal = 20; // 静态全局变量，内部链接

// File2.cpp
extern int globalVar;         // 正确：可以访问File1中的globalVar
// extern int staticGlobal;   // 错误：无法访问File1中的staticGlobal

// config.h
extern const int MAX_USERS;  // 全局常量，多个文件共享

// helper.cpp
static int helperCounter = 0;  // 静态全局，只在helper.cpp中使用
void helperFunction() {
    helperCounter++;  // 安全，不会与其他文件冲突
}

// main.cpp
int sharedData = 0;  // 全局变量，其他文件可访问
static int fileLocal = 0;  // 静态全局，只在main.cpp中可用

// header.h
inline int sharedValue = 42;  // 每个包含该头文件的TU共享同一实例

extern "C" void c_function(int x);
extern "C" int c_variable;

extern "C" {
    void func1(int);
    int func2(double);
    extern int global_var;
}

// C 库头文件 (c_library.h)
#ifdef __cplusplus
extern "C" {
#endif

void c_function(int x);
int c_variable;

#ifdef __cplusplus
}
#endif

// C++ 代码
#include "c_library.h"

int main() {
    c_function(42);      // 正确：C++ 调用 C 函数
    int x = c_variable; // 正确：访问 C 全局变量
    return 0;
}

// C++ 头文件 (cpp_library.h)
#ifdef __cplusplus
extern "C" {
#endif

// 这些函数将使用 C 链接
void cpp_function_for_c(int x);
int get_value(void);

#ifdef __cplusplus
}
#endif

// C++ 实现文件
#include "cpp_library.h"
#include <iostream>

void cpp_function_for_c(int x) {
    std::cout << "Called from C with: " << x << std::endl;
}

int get_value() {
    return 100;
}

// C 调用方
#include "cpp_library.h"

int main() {
    cpp_function_for_c(123);  // C 调用 C++ 函数
    int val = get_value();
    return 0;
}

// 跨语言头文件示例
#ifndef MY_LIB_H
#define MY_LIB_H

#ifdef __cplusplus
extern "C" {
#endif

// 函数声明
int add(int a, int b);
void process_data(const char* data);

// 变量声明
extern int global_counter;

#ifdef __cplusplus
}
#endif

#endif // MY_LIB_H

// 在 C++ 文件中
extern "C" {
    // C 接口函数
    int create_object() {
        return static_cast<int>(reinterpret_cast<size_t>(new MyClass()));
    }
    
    void use_object(int handle, int value) {
        MyClass* obj = reinterpret_cast<MyClass*>(handle);
        obj->do_something(value);
    }
    
    void destroy_object(int handle) {
        delete reinterpret_cast<MyClass*>(handle);
    }
}

// 正确的混合使用
extern "C" {
    // 普通函数 - 正确
    int plain_c_function(int x, int y);
    
    // 使用 C++ 类型 - 需要特殊处理
    void process_with_cpp_types(const std::string* str);  // 危险：C 不认识 std::string
}

// DLL 导出
#ifdef MYLIB_EXPORTS
    #define MYLIB_API __declspec(dllexport)
#else
    #define MYLIB_API __declspec(dllimport)
#endif

#ifdef __cplusplus
extern "C" {
#endif

MYLIB_API int __stdcall Add(int a, int b);
MYLIB_API void __stdcall Initialize();

#ifdef __cplusplus
}
#endif

// 简单的共享库接口
#ifdef __cplusplus
extern "C" {
#endif

int mylib_init(void);
int mylib_process(const char* input, char* output, int size);
void mylib_cleanup(void);

#ifdef __cplusplus
}
#endif

// cpp_class_wrapper.h
#ifdef __cplusplus
extern "C" {
#endif

// 不透明句柄
typedef void* MyClassHandle;

// C 接口
MyClassHandle create_myclass();
void myclass_do_something(MyClassHandle handle, int value);
void destroy_myclass(MyClassHandle handle);

#ifdef __cplusplus
}
#endif

// cpp_class_wrapper.cpp
#include "my_class.hpp"  // C++ 类定义
#include "cpp_class_wrapper.h"

extern "C" {
    MyClassHandle create_myclass() {
        return reinterpret_cast<MyClassHandle>(new MyClass());
    }
    
    void myclass_do_something(MyClassHandle handle, int value) {
        MyClass* obj = reinterpret_cast<MyClass*>(handle);
        obj->do_something(value);
    }
    
    void destroy_myclass(MyClassHandle handle) {
        delete reinterpret_cast<MyClass*>(handle);
    }
}

## Linux/Unix
nm mylibrary.o | grep function_name

## Windows
dumpbin /symbols mylibrary.obj

// 使用标准布局类型
struct alignas(16) MyData {
    int x;
    double y;
    char name[32];
};

extern "C" {
    void process_data(const MyData* data);
}

volatile int counter;           // volatile 整型
volatile int* ptr;              // 指向 volatile 数据的指针
int* volatile ptr2;             // volatile 指针（指针本身是 volatile）
volatile int* volatile ptr3;    // 两者都是 volatile

// 假设 0x40021000 是 GPIO 端口的地址
volatile uint32_t* const gpio_port = reinterpret_cast<volatile uint32_t*>(0x40021000);

void set_led() {
    *gpio_port = 0x01;  // 写入硬件寄存器
    // 如果没有 volatile，编译器可能优化掉这个"看似无用"的写入
}

// 共享标志位
volatile bool data_ready = false;

// 中断服务程序
void interrupt_handler() {
    data_ready = true;  // 异步设置标志
}

// 主循环
void main_loop() {
    while (!data_ready) {  // 如果没有 volatile，可能被优化为 while(true)
        // 等待数据
    }
    process_data();
}

#include <csignal>
#include <iostream>

volatile sig_atomic_t signal_received = 0;

void signal_handler(int signal) {
    signal_received = signal;
}

int main() {
    std::signal(SIGINT, signal_handler);
    
    while (signal_received == 0) {
        // 正常处理
    }
    std::cout << "Received signal: " << signal_received << std::endl;
    return 0;
}

int flag = 0;

void wait_for_flag() {
    while (flag == 0) {
        // 空循环
    }
}

// 编译器可能优化为：
void wait_for_flag_optimized() {
    if (flag == 0) {  // 只检查一次
        while (true) {  // 死循环
        }
    }
}

volatile int flag = 0;

void wait_for_flag() {
    while (flag == 0) {
        // 每次循环都会从内存读取 flag
    }
}
// 不会被优化掉

volatile int a = 0;
volatile int b = 0;

void test() {
    a = 1;    // 保证在 b = 2 之前执行
    b = 2;    // 保证在 a = 1 之后执行
    // 对 volatile 变量的访问不会被编译器重排序
}

volatile int* hardware_register = ...;

void write_to_device() {
    *hardware_register = 0xAA;  // 保证执行一次
    *hardware_register = 0xBB;  // 保证执行一次
    *hardware_register = 0xCC;  // 保证执行一次
    // 三次写入都不会被优化掉
}

// 错误：认为 volatile 能保证原子性
volatile int counter = 0;

void thread_func() {
    for (int i = 0; i < 1000; ++i) {
        ++counter;  // 不是原子操作！
        // 在多核 CPU 上仍可能出现数据竞争
    }
}

// 错误示例：volatile 不适合多线程同步
class IncorrectCounter {
    volatile int value = 0;
public:
    void increment() { ++value; }  // 非线程安全！
    int get() const { return value; }
};

#include <atomic>
#include <mutex>

// 正确做法 1：使用 atomic
std::atomic<int> atomic_counter{0};  // 原子操作，有内存顺序保证

// 正确做法 2：使用 mutex
class SafeCounter {
    mutable std::mutex mtx;
    int value = 0;
public:
    void increment() {
        std::lock_guard<std::mutex> lock(mtx);
        ++value;
    }
    int get() const {
        std::lock_guard<std::mutex> lock(mtx);
        return value;
    }
};

// 只读的硬件寄存器
volatile const uint32_t* const status_register = 
    reinterpret_cast<volatile const uint32_t*>(0x40021004);

uint32_t get_status() {
    return *status_register;  // 从寄存器读取，但不会写入
}

struct DeviceRegisters {
    volatile uint32_t control;
    volatile uint32_t status;
    volatile uint32_t data;
};

volatile DeviceRegisters* dev = 
    reinterpret_cast<volatile DeviceRegisters*>(0x40020000);

void init_device() {
    dev->control = 0x01;  // 访问 volatile 成员
}

// volatile 作为简单的编译器屏障
#define COMPILER_BARRIER() asm volatile("" ::: "memory")

void memory_operation() {
    int x = 1;
    volatile int y = 2;  // 防止某些优化
    
    COMPILER_BARRIER();  // 更明确的屏障
    
    int z = x + y;
}

class HardwareTimer {
    volatile uint32_t* const counter_reg;
    volatile uint32_t* const control_reg;
    
public:
    HardwareTimer(uintptr_t base_addr)
        : counter_reg(reinterpret_cast<volatile uint32_t*>(base_addr))
        , control_reg(reinterpret_cast<volatile uint32_t*>(base_addr + 4)) {}
    
    void wait_until(uint32_t value) {
        while (*counter_reg < value) {
            // 必须从内存读取，不能缓存
        }
    }
    
    void start() {
        *control_reg = 0x01;
    }
};

template<typename T>
class DoubleBuffer {
    T buffer1[1024];
    T buffer2[1024];
    volatile T* volatile current_buffer = buffer1;  // 当前使用的缓冲区
    
public:
    // 生产者线程
    void write_data(const T* data, size_t size) {
        T* write_buffer = (current_buffer == buffer1) ? buffer2 : buffer1;
        std::copy(data, data + size, write_buffer);
        
        // 交换缓冲区
        COMPILER_BARRIER();
        current_buffer = write_buffer;
    }
    
    // 消费者线程
    void process_data() {
        volatile T* read_buffer = current_buffer;  // 获取当前缓冲区
        // 处理数据...
    }
};

#include <atomic>
#include <iostream>

void compare_volatile_atomic() {
    volatile int v = 0;
    std::atomic<int> a{0};
    
    // volatile: 无原子性，无内存顺序保证
    ++v;  // 不是原子操作
    
    // atomic: 有原子性，有内存顺序保证
    a.fetch_add(1, std::memory_order_relaxed);
    
    // atomic 可以替代 volatile 的大部分用途
    std::atomic<int> flag{0};
    while (flag.load(std::memory_order_acquire) == 0) {
        // 等待
    }
}

std::atomic<int> data{0};
std::atomic<bool> ready{false};

// 线程 1
data.store(42, std::memory_order_relaxed);
ready.store(true, std::memory_order_release);  // 释放操作

// 线程 2
while (!ready.load(std::memory_order_acquire)) {  // 获取操作
    // 等待
}
int value = data.load(std::memory_order_relaxed);  // 保证看到 42

// x86 有较强的内存模型，但 volatile 仍需要
volatile int* shared = ...;
*shared = 1;  // 保证对其他核心可见（由于 x86 的缓存一致性协议）

// ARM 有较弱的内存模型
volatile uint32_t* reg = ...;
*reg = 1;  // 可能需要内存屏障
// 在 ARM 上，有时需要：
asm volatile("dmb ish" ::: "memory");  // 数据内存屏障

volatile int v = 0;
int nv = 0;

void test() {
    v = 1;  // 一定会有存储指令
    nv = 1; // 可能被优化掉
    v = 2;  // 两次写入都会保留
}
// 使用 gcc -S 查看汇编代码

// 现代 C++ 的推荐做法
class Device {
private:
    // 硬件访问
    volatile uint32_t* const hw_register;
    
    // 线程间共享
    std::atomic<bool> device_ready{false};
    std::mutex data_mutex;
    std::vector<uint8_t> buffer;
    
public:
    **Device(uintptr_t addr)**：hw_register(reinterpret_cast<volatile uint32_t*>(addr)) {}
    
    // 硬件操作
    void write_to_device(uint32_t value) {
        *hw_register = value;  // 使用 volatile
    }
    
    // 线程安全操作
    void set_ready(bool ready) {
        device_ready.store(ready, std::memory_order_release);  // 使用 atomic
    }
};

class Base {
public:
    void publicFunc() { cout << "Base public\n"; }
protected:
    void protectedFunc() { cout << "Base protected\n"; }
private:
    void privateFunc() { cout << "Base private\n"; }
};

class Derived : private Base {  // 私有继承
public:
    void useBase() {
        publicFunc();     // OK: 在派生类内部可访问
        protectedFunc();  // OK: 在派生类内部可访问
        // privateFunc(); // 错误: 基类私有成员不可访问
    }
};

int main() {
    Derived d;
    // d.publicFunc();  // 错误: 在类外不可访问
    d.useBase();         // OK
}

class Base {
public:
    int pub;
protected:
    int prot;
private:
    int priv;
};

// 公有继承
class PublicDerived : public Base {
    // pub 是 public
    // prot 是 protected
    // priv 不可访问
};

// 保护继承
class ProtectedDerived : protected Base {
    // pub 是 protected
    // prot 是 protected
    // priv 不可访问
};

// 私有继承
class PrivateDerived : private Base {
    // pub 是 private
    // prot 是 private
    // priv 不可访问
};

class Base {};
class Derived : private Base {};

int main() {
    Derived d;
    Base& b = d;  // 错误: 私有继承不能向上转型
    // 公有继承可以: Base& b = d;
}

// 使用组合
class Engine {
public:
    void start() { cout << "Engine started\n"; }
};

class Car {
private:
    Engine engine;  // 组合
public:
    void start() { engine.start(); }
};

// 使用私有继承
class Car2 : private Engine {  // 私有继承
public:
    using Engine::start;  // 暴露特定接口
};

// 当需要访问基类的保护成员时
class BaseCollection {
protected:
    struct Node {
        int data;
        Node* next;
    };
    Node* head = nullptr;
};

// 只有通过继承才能访问保护成员
class LinkedList : private BaseCollection {
public:
    void add(int value) {
        Node* newNode = new Node{value, head};
        head = newNode;
    }
    
    void print() const {
        Node* current = head;
        while (current) {
            cout << current->data << " ";
            current = current->next;
        }
    }
};

class TimerBase {
public:
    virtual ~TimerBase() = default;
    virtual void onTick() = 0;
    
    void start() {
        // 定时器逻辑
        onTick();  // 调用派生类的实现
    }
};

// 用户不需要知道 TimerBase 的存在
class MyTimer : private TimerBase {
private:
    void onTick() override {  // 私有继承，外部不能调用
        cout << "Tick!\n";
    }
public:
    using TimerBase::start;  // 只暴露 start 方法
};

// 第三方库的复杂接口
class ThirdPartyStack {
public:
    void push(int x) { /* 复杂实现 */ }
    int pop() { /* 复杂实现 */ return 0; }
    bool empty() const { return true; }
};

// 适配为标准栈接口
class StackAdapter : private ThirdPartyStack {
public:
    // 重新定义更友好的接口
    void push(int value) { 
        ThirdPartyStack::push(value); 
    }
    
    int top() {
        if (empty()) throw runtime_error("Stack empty");
        // 需要一些额外逻辑
        return peekTop();  // 假设 ThirdPartyStack 有这个方法
    }
    
    int pop_top() {
        int result = top();
        ThirdPartyStack::pop();
        return result;
    }
    
    // 可以添加额外功能
    size_t size() const { 
        // 计算大小
        return calculateSize();
    }
private:
    int peekTop() { /* 实现 */ return 0; }
    size_t calculateSize() const { /* 实现 */ return 0; }
};

// 空基类
class EmptyBase {
    // 没有任何数据成员
public:
    void helper() { cout << "Helper\n"; }
};

// 没有 EBO
class WithoutEBO {
    int data;
    EmptyBase helper;  // 占用空间（可能有填充）
};  // 可能大于 sizeof(int)

// 有 EBO（空基类优化）
class WithEBO : private EmptyBase {
    int data;
};  // 通常等于 sizeof(int)

// 可复用的实现
class Copyable {
protected:
    virtual ~Copyable() = default;
    virtual void* cloneImpl() const = 0;
    
public:
    std::unique_ptr<Copyable> clone() const {
        return std::unique_ptr<Copyable>(static_cast<Copyable*>(cloneImpl()));
    }
};

// 使用私有继承获得可克隆功能
class MyObject : private Copyable {
private:
    int data;
    
    // 实现克隆
    void* cloneImpl() const override {
        return new MyObject(*this);
    }
    
public:
    MyObject(int d) : data(d) {}
    
    // 暴露克隆接口
    std::unique_ptr<MyObject> clone() const {
        return std::unique_ptr<MyObject>(static_cast<MyObject*>(cloneImpl()));
    }
    
    int getData() const { return data; }
};

// 情况1：需要访问保护成员 → 考虑私有继承
class Base {
protected:
    int internal_data;
};

class Derived1 : private Base {  // 私有继承
    void use() { internal_data = 42; }  // 直接访问
};

class Derived2 {  // 组合
    Base base;  // 无法访问 internal_data
};

// 情况2：不需要特殊功能 → 使用组合
class Engine {};

class Car1 {  // 组合（推荐）
    Engine engine;
public:
    void start() { /* 使用 engine */ }
};

class Car2 : private Engine {  // 私有继承（不推荐）
public:
    void start() { /* 可以直接调用 Engine 方法 */ }
};

class VirtualBase {
public:
    virtual void func() = 0;
    virtual ~VirtualBase() = default;
};

class Implementation : private virtual VirtualBase {
private:
    void func() override { cout << "Implementation\n"; }
    
protected:
    // 防止外部通过 VirtualBase 指针删除
    ~Implementation() = default;
};

class Interface1 {
public:
    virtual void method1() = 0;
    virtual ~Interface1() = default;
};

class Interface2 {
public:
    virtual void method2() = 0;
    virtual ~Interface2() = default;
};

// 实现多个接口但不暴露
class Implementation : private Interface1, private Interface2 {
private:
    void method1() override { cout << "method1\n"; }
    void method2() override { cout << "method2\n"; }
    
public:
    // 提供访问方式
    void callMethod1() { method1(); }
    void callMethod2() { method2(); }
};

// widget.h
class Widget {
public:
    Widget();
    ~Widget();
    void draw();
    
private:
    class Impl;  // 前向声明
    std::unique_ptr<Impl> pImpl;
};

// widget.cpp
class Widget::Impl : private GraphicsLibrary {  // 私有继承图形库
private:
    // 可以访问 GraphicsLibrary 的保护成员
    void setup() {
        initGraphics();  // 保护方法
    }
    
public:
    void render() {
        // 使用图形库功能
        drawPrimitive();  // 保护方法
    }
};

Widget::Widget() : pImpl(std::make_unique<Impl>()) {}
Widget::~Widget() = default;
void Widget::draw() { pImpl->render(); }

// 策略类
template<typename T>
class AllocatorStrategy {
protected:
    T* allocate(size_t n) {
        return static_cast<T*>(::operator new(n * sizeof(T)));
    }
    
    **void deallocate(T* p, size_t) {**：:operator delete(p);
    }
};

// 使用私有继承获取分配策略
template<typename T, typename Allocator = AllocatorStrategy<T>>
class Vector : private Allocator {  // 私有继承策略
private:
    T* data = nullptr;
    size_t size = 0;
    size_t capacity = 0;
    
    T* allocate_memory(size_t n) {
        return this->allocate(n);  // 使用策略
    }
    
    void deallocate_memory(T* p, size_t n) {
        if (p) this->deallocate(p, n);
    }
    
public:
    ~Vector() {
        deallocate_memory(data, capacity);
    }
    
    void push_back(const T& value) {
        if (size == capacity) {
            // 重新分配内存
            size_t new_cap = capacity ? capacity * 2 : 1;
            T* new_data = allocate_memory(new_cap);
            // ... 复制元素
            deallocate_memory(data, capacity);
            data = new_data;
            capacity = new_cap;
        }
        // ... 构造新元素
    }
};

class Base {
public:
    void api() { cout << "Base API\n"; }
};

class Derived : private Base {
    // 没有隐藏 Base::api
};

int main() {
    Derived d;
    // d.api();  // 错误: api 是私有的
    
    // 但可以通过转型访问
    Base& b = static_cast<Base&>(d);  // 危险！
    b.api();  // 可以调用
}

class ResourceHolder {
protected:
    ~ResourceHolder() {}  // 保护析构函数
};

class BadDerived : private ResourceHolder {
    // 可以访问保护析构函数
public:
    ~BadDerived() {
        // ResourceHolder 析构函数自动调用
    }
};

int main() {
    // BadDerived d;  // 错误: ResourceHolder 析构不可访问
    // 即使 BadDerived 是栈对象，也要通过指针控制
    BadDerived* pd = new BadDerived();
    delete pd;  // 错误: ~ResourceHolder() 不可访问
}

// 推荐：组合
class MyClass {
private:
    Helper helper;  // 组合
public:
    void doWork() { helper.help(); }
};

// 特殊需求：私有继承
class MyClass2 : private Helper {  // 需要特殊功能时才用
    // 可以访问 Helper 的保护成员
};

// 不好的写法
class MyStack : private std::vector<int> {  // 意图不明显
public:
    void push(int x) { push_back(x); }
    int pop() { 
        int x = back();
        pop_back();
        return x;
    }
};

// 更好的写法
class MyStack {  // 组合
private:
    std::vector<int> data;
public:
    void push(int x) { data.push_back(x); }
    int pop() { 
        int x = data.back();
        data.pop_back();
        return x;
    }
};

class Base {
public:
    void publicMethod() {}
protected:
    void protectedMethod() {}
};

class Derived : private Base {
public:
    using Base::publicMethod;  // 将基类公有方法暴露为公有
    using Base::protectedMethod;  // 将基类保护方法暴露为公有
};

int main() {
    Derived d;
    d.publicMethod();     // OK
    d.protectedMethod();  // OK
}

template<typename Derived>
class Singleton {
protected:
    Singleton() = default;
    
public:
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
    
    static Derived& instance() {
        static Derived instance;
        return instance;
    }
};

// 使用私有继承
class MySingleton : private Singleton<MySingleton> {
private:
    friend class Singleton<MySingleton>;  // 允许访问构造函数
    MySingleton() = default;
    
public:
    using Singleton<MySingleton>::instance;  // 暴露实例获取方法
    
    void doSomething() { cout << "Singleton working\n"; }
};

template<typename T>
concept Allocator = requires(T alloc, size_t n) {
    { alloc.allocate(n) } -> std::same_as<void*>;
    { alloc.deallocate(nullptr, n) } -> std::same_as<void>;
};

// 使用私有继承实现策略
template<Allocator Alloc>
class Container : private Alloc {  // 私有继承满足概念的类型
    // 可以使用 Alloc 的方法
};

// 函数指针
int add(int a, int b) { return a + b; }

// 仿函数
struct Add {
    int operator()(int a, int b) const {
        return a + b;
    }
};

int main() {
    // 函数指针是函数对象
    int (*func_ptr)(int, int) = &add;
    cout << func_ptr(1, 2) << endl;  // 输出 3
    
    // 仿函数是函数对象
    Add add_functor;
    cout << add_functor(1, 2) << endl;  // 输出 3
    
    return 0;
}

// 基本仿函数
struct Add {
    int operator()(int a, int b) const {
        return a + b;
    }
};

// 有状态的仿函数
class Multiplier {
    int factor;
public:
    explicit Multiplier(int f) : factor(f) {}
    
    int operator()(int x) const {
        return x * factor;
    }
    
    void set_factor(int f) { factor = f; }
};

// 模板仿函数
template<typename T>
struct Comparator {
    bool operator()(const T& a, const T& b) const {
        return a < b;
    }
};

int main() {
    // Lambda 本质是匿名的函数对象
    auto add = int a, int b { return a + b; };
    cout << add(1, 2) << endl;  // 输出 3
    
    // 有状态的 lambda
    int factor = 3;
    auto multiply = int x { return x * factor; };
    cout << multiply(5) << endl;  // 输出 15
    
    // 通用 lambda (C++14+)
    auto generic_add = auto a, auto b { return a + b; };
    cout << generic_add(1, 2) << endl;    // 3
    cout << generic_add(1.5, 2.5) << endl;  // 4.0
    
    return 0;
}

#include <functional>
#include <iostream>

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

struct Multiply {
    int operator()(int a, int b) const { return a * b; }
};

int main() {
    // std::function 可以包装任何可调用对象
    std::function<int(int, int)> func;
    
    // 包装函数指针
    func = add;
    cout << func(3, 4) << endl;  // 7
    
    // 包装仿函数
    func = Multiply();
    cout << func(3, 4) << endl;  // 12
    
    // 包装 lambda
    func = int a, int b { return a - b; };
    cout << func(10, 3) << endl;  // 7
    
    return 0;
}

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

int main() {
    std::vector<int> nums = {1, 2, 3, 4, 5};
    
    // 使用仿函数
    struct Square {
        int operator()(int x) const { return x * x; }
    };
    std::transform(nums.begin(), nums.end(), nums.begin(), Square());
    
    // 使用 lambda
    std::transform(nums.begin(), nums.end(), nums.begin(),
                   int x { return x * x; });
    
    // 使用标准库仿函数
    std::sort(nums.begin(), nums.end(), std::greater<int>());
    
    for (int n : nums) cout << n << " ";
    return 0;
}

#include <vector>
#include <functional>

class EventSystem {
    std::vector<std::function<void(int)>> listeners;
    
public:
    template<typename Callable>
    void add_listener(Callable&& callback) {
        listeners.emplace_back(std::forward<Callable>(callback));
    }
    
    void trigger_event(int value) {
        for (auto& listener : listeners) {
            listener(value);
        }
    }
};

int main() {
    EventSystem events;
    
    // 添加各种回调
    events.add_listener(int x { 
        std::cout << "Lambda: " << x << std::endl; 
    });
    
    struct Handler {
        void operator()(int x) const {
            std::cout << "Functor: " << x << std::endl;
        }
    };
    events.add_listener(Handler());
    
    // 触发事件
    events.trigger_event(42);
    return 0;
}

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

// 排序策略
struct Ascending {
    template<typename T>
    bool operator()(const T& a, const T& b) const { return a < b; }
};

struct Descending {
    template<typename T>
    bool operator()(const T& a, const T& b) const { return a > b; }
};

template<typename Container, typename Comparator>
void sort_with_strategy(Container& c, Comparator comp) {
    std::sort(c.begin(), c.end(), comp);
}

int main() {
    std::vector<int> nums = {5, 2, 8, 1, 9};
    
    // 使用仿函数策略
    sort_with_strategy(nums, Ascending());
    for (int n : nums) std::cout << n << " ";  // 1 2 5 8 9
    std::cout << std::endl;
    
    // 使用 lambda 策略
    sort_with_strategy(nums, int a, int b { return a > b; });
    for (int n : nums) std::cout << n << " ";  // 9 8 5 2 1
    std::cout << std::endl;
    
    return 0;
}

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

int main() {
    std::vector<int> nums = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    
    // 使用 bind 创建函数对象
    auto is_multiple_of = int n, int divisor {
        return n % divisor == 0;
    };
    
    // 绑定除数参数
    auto is_multiple_of_3 = std::bind(is_multiple_of, 
                                      std::placeholders::_1, 3);
    auto is_multiple_of_5 = std::bind(is_multiple_of,
                                      std::placeholders::_1, 5);
    
    // 使用函数适配器
    int count3 = std::count_if(nums.begin(), nums.end(), is_multiple_of_3);
    int count5 = std::count_if(nums.begin(), nums.end(), is_multiple_of_5);
    
    std::cout << "Multiples of 3: " << count3 << std::endl;
    std::cout << "Multiples of 5: " << count5 << std::endl;
    
    return 0;
}

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

template<typename F1, typename F2>
class Compose {
    F1 f1;
    F2 f2;
public:
    Compose(F1 f1_, F2 f2_) : f1(f1_), f2(f2_) {}
    
    template<typename T>
    auto operator()(T x) const -> decltype(f2(f1(x))) {
        return f2(f1(x));
    }
};

int main() {
    auto square = int x { return x * x; };
    auto increment = int x { return x + 1; };
    
    // 组合函数：先平方，再加1
    Compose<decltype(square), decltype(increment)> 
        square_then_increment(square, increment);
    
    std::cout << square_then_increment(3) << std::endl;  // 10
    
    // C++20 可以用 ranges
    auto composed = int x { return increment(square(x)); };
    std::cout << composed(3) << std::endl;  // 10
    
    return 0;
}

// 函数指针 - 可能无法内联
int process(int x, int (*func)(int)) {
    return func(x);
}

// 仿函数模板 - 总是内联
template<typename Func>
int process_template(int x, Func func) {
    return func(x);
}

struct Square {
    int operator()(int x) const { return x * x; }
};

int main() {
    int (*func_ptr)(int) = int x { return x * x; };
    
    // 可能无法内联
    int a = process(5, func_ptr);
    
    // 总是内联
    int b = process_template(5, Square());
    int c = process_template(5, int x { return x * x; });
    
    return 0;
}

#include <iostream>
#include <functional>

struct LargeFunctor {
    char data[100];  // 大量数据
    int operator()(int x) const { return x + data[0]; }
};

int main() {
    std::cout << "sizeof(LargeFunctor): " << sizeof(LargeFunctor) << std::endl;
    
    // std::function 有固定大小，但可能分配堆内存
    std::function<int(int)> f1 = LargeFunctor();
    std::cout << "sizeof(std::function): " << sizeof(f1) << std::endl;
    
    // lambda 大小取决于捕获
    int a = 10;
    auto lambda = int x { return x + a; };
    std::cout << "sizeof(lambda): " << sizeof(lambda) << std::endl;
    
    return 0;
}