C++中包装器的使用示例

#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 << "旧接口执行任务：" << msg << std::endl;
    }
};

// 新接口（统一规范）
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);
    }
};

// 新代码使用统一接口
void use_new_interface(NewInterface& obj) {
    obj.execute("完成数据处理");
}

int main() {
    OldToNewAdapter adapter;
    use_new_interface(adapter);  // 输出：旧接口执行任务：适配后：完成数据处理
    return 0;
}