#include <functional>
#include <iostream>

// 普通函數
int add(int a, int b) { return a + b; }

// 函數對象（仿函數）
struct Multiply {
    int operator()(int a, int b) { return a * b; }
};

// 類成員函數
class Calculator {
public:
    int subtract(int a, int b) { return a - b; }
};

int main() {
    // 包裝普通函數
    std::function<int(int, int)> func1 = add;
    std::cout << func1(2, 3) << std::endl;  // 輸出 5

    // 包裝函數對象
    std::function<int(int, int)> func2 = Multiply{};
    std::cout << func2(2, 3) << std::endl;  // 輸出 6

    // 包裝 lambda 表達式
    std::function<int(int, int)> func3 = [](int a, int b) { return a / b; };
    std::cout << func3(6, 2) << std::endl;  // 輸出 3

    // 包裝類成員函數（需綁定實例）
    Calculator calc;
    std::function<int(int, int)> func4 = std::bind(&Calculator::subtract, &calc, std::placeholders::_1, std::placeholders::_2);
    std::cout << func4(5, 2) << std::endl;  // 輸出 3

    return 0;
}

#include <memory>
#include <iostream>

class MyClass {
public:
    MyClass() { std::cout << "MyClass 構造" << std::endl; }
    ~MyClass() { std::cout << "MyClass 析構" << std::endl; }
    void show() { std::cout << "Hello MyClass" << std::endl; }
};

int main() {
    // std::unique_ptr：獨占所有權
    std::unique_ptr<MyClass> ptr1 = std::make_unique<MyClass>();
    ptr1->show();  // 接口與裸指針一致

    // std::shared_ptr：共享所有權（引用計數）
    std::shared_ptr<MyClass> ptr2 = std::make_shared<MyClass>();
    std::shared_ptr<MyClass> ptr3 = ptr2;  // 引用計數+1
    ptr3->show();

    // 無需手動 delete，作用域結束時自動析構
    return 0;
}

#include <vector>
#include <iostream>
#include <iterator>  // 包含迭代器適配器

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

    // 正向遍歷
    std::cout << "正向遍歷：";
    for (auto it = vec.begin(); it != vec.end(); ++it) {
        std::cout << *it << " ";  // 輸出 1 2 3 4 5
    }
    std::cout << std::endl;

    // 反向遍歷（使用 reverse_iterator 包裝 begin()/end()）
    std::cout << "反向遍歷：";
    for (auto it = std::reverse_iterator(vec.end()); it != std::reverse_iterator(vec.begin()); ++it) {
        std::cout << *it << " ";  // 輸出 5 4 3 2 1
    }
    std::cout << std::endl;

    return 0;
}

#include <functional>
#include <iostream>

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

int main() {
    // 綁定第一個參數為 10，生成新函數：int(int, int)
    auto add10 = std::bind(add, 10, std::placeholders::_1, std::placeholders::_2);
    std::cout << add10(2, 3) << std::endl;  // 10+2+3=15

    // 綁定后兩個參數為 5、6，生成新函數：int(int)
    auto add56 = std::bind(add, std::placeholders::_1, 5, 6);
    std::cout << add56(4) << std::endl;  // 4+5+6=15

    return 0;
}

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

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

    // 查找偶數（原邏輯：x % 2 == 0）
    auto even = [](int x) { return x % 2 == 0; };
    auto it1 = std::find_if(vec.begin(), vec.end(), even);
    std::cout << "第一個偶數：" << *it1 << std::endl;  // 輸出 2

    // 查找奇數（包裝 even，邏輯取反）
    auto odd = std::not_fn(even);
    auto it2 = std::find_if(vec.begin(), vec.end(), odd);
    std::cout << "第一個奇數：" << *it2 << std::endl;  // 輸出 1

    return 0;
}

#include <iostream>
#include <string>

// 舊接口（無法修改）
class OldInterface {
public:
    void do_old_task(const std::string& msg) {
        std::cout << "舊接口執(zhí)行任務：" << msg << std::endl;
    }
};

// 新接口（統(tǒng)一規(guī)范）
class NewInterface {
public:
    virtual ~NewInterface() = default;
    virtual void execute(const std::string& task) = 0;
};

// 包裝器（適配器）：將 OldInterface 適配為 NewInterface
class OldToNewAdapter : public NewInterface {
private:
    OldInterface old_obj;  // 包裝舊接口對象
public:
    void execute(const std::string& task) override {
        // 轉換接口：新接口的 execute 調用舊接口的 do_old_task
        old_obj.do_old_task("適配后：" + task);
    }
};

// 新代碼使用統(tǒng)一接口
void use_new_interface(NewInterface& obj) {
    obj.execute("完成數據處理");
}

int main() {
    OldToNewAdapter adapter;
    use_new_interface(adapter);  // 輸出：舊接口執(zhí)行任務：適配后：完成數據處理
    return 0;
}