【C++】C++中的设计模式

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

#include <mutex>
#include <memory>

class Singleton {
public:
    // 删除拷贝构造和赋值运算符
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
    
    // 获取单例实例
    static Singleton& getInstance() {
        static Singleton instance;  // C++11保证线程安全
        return instance;
    }
    
    void doSomething() {
        // 业务逻辑
    }
    
private:
    Singleton() {
        // 私有构造函数
    }
    ~Singleton() = default;
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

class Singleton {
public:
    static Singleton* getInstance() {
        if (instance == nullptr) {
            std::lock_guard<std::mutex> lock(mutex);
            if (instance == nullptr) {
                instance = new Singleton();
            }
        }
        return instance;
    }
    
private:
    Singleton() = default;
    static Singleton* instance;
    static std::mutex mutex;
};

// 静态成员初始化
Singleton* Singleton::instance = nullptr;
std::mutex Singleton::mutex;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

#include <iostream>
#include <memory>

// 产品基类
class Product {
public:
    virtual ~Product() = default;
    virtual void use() = 0;
};

// 具体产品A
class ConcreteProductA : public Product {
public:
    void use() override {
        std::cout << "使用产品A" << std::endl;
    }
};

// 具体产品B
class ConcreteProductB : public Product {
public:
    void use() override {
        std::cout << "使用产品B" << std::endl;
    }
};

// 工厂基类
class Factory {
public:
    virtual ~Factory() = default;
    virtual std::unique_ptr<Product> createProduct() = 0;
};

// 具体工厂A
class ConcreteFactoryA : public Factory {
public:
    std::unique_ptr<Product> createProduct() override {
        return std::make_unique<ConcreteProductA>();
    }
};

// 具体工厂B
class ConcreteFactoryB : public Factory {
public:
    std::unique_ptr<Product> createProduct() override {
        return std::make_unique<ConcreteProductB>();
    }
};

// 使用示例
int main() {
    std::unique_ptr<Factory> factory = std::make_unique<ConcreteFactoryA>();
    std::unique_ptr<Product> product = factory->createProduct();
    product->use();
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

#include <iostream>
#include <memory>

// 抽象产品A
class AbstractProductA {
public:
    virtual ~AbstractProductA() = default;
    virtual void useA() = 0;
};

// 抽象产品B
class AbstractProductB {
public:
    virtual ~AbstractProductB() = default;
    virtual void useB() = 0;
};

// 具体产品A1
class ProductA1 : public AbstractProductA {
public:
    void useA() override { std::cout << "使用产品A1" << std::endl; }
};

// 具体产品A2
class ProductA2 : public AbstractProductA {
public:
    void useA() override { std::cout << "使用产品A2" << std::endl; }
};

// 具体产品B1
class ProductB1 : public AbstractProductB {
public:
    void useB() override { std::cout << "使用产品B1" << std::endl; }
};

// 具体产品B2
class ProductB2 : public AbstractProductB {
public:
    void useB() override { std::cout << "使用产品B2" << std::endl; }
};

// 抽象工厂
class AbstractFactory {
public:
    virtual ~AbstractFactory() = default;
    virtual std::unique_ptr<AbstractProductA> createProductA() = 0;
    virtual std::unique_ptr<AbstractProductB> createProductB() = 0;
};

// 具体工厂1 - 创建产品族1
class ConcreteFactory1 : public AbstractFactory {
public:
    std::unique_ptr<AbstractProductA> createProductA() override {
        return std::make_unique<ProductA1>();
    }
    std::unique_ptr<AbstractProductB> createProductB() override {
        return std::make_unique<ProductB1>();
    }
};

// 具体工厂2 - 创建产品族2
class ConcreteFactory2 : public AbstractFactory {
public:
    std::unique_ptr<AbstractProductA> createProductA() override {
        return std::make_unique<ProductA2>();
    }
    std::unique_ptr<AbstractProductB> createProductB() override {
        return std::make_unique<ProductB2>();
    }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

#include <iostream>
#include <string>

// 产品 - 电脑
class Computer {
public:
    void setCPU(const std::string& cpu) { m_cpu = cpu; }
    void setRAM(const std::string& ram) { m_ram = ram; }
    void setStorage(const std::string& storage) { m_storage = storage; }
    void setGPU(const std::string& gpu) { m_gpu = gpu; }
    
    void show() const {
        std::cout << "电脑配置: \n"
                  << "  CPU: " << m_cpu << "\n"
                  << "  RAM: " << m_ram << "\n"
                  << "  存储: " << m_storage << "\n"
                  << "  GPU: " << m_gpu << "\n";
    }
    
private:
    std::string m_cpu;
    std::string m_ram;
    std::string m_storage;
    std::string m_gpu;
};

// 抽象建造者
class ComputerBuilder {
public:
    virtual ~ComputerBuilder() = default;
    virtual void buildCPU() = 0;
    virtual void buildRAM() = 0;
    virtual void buildStorage() = 0;
    virtual void buildGPU() = 0;
    virtual Computer getResult() = 0;
};

// 具体建造者 - 游戏电脑
class GamingComputerBuilder : public ComputerBuilder {
public:
    void buildCPU() override { m_computer.setCPU("Intel i9-14900K"); }
    void buildRAM() override { m_computer.setRAM("64GB DDR5"); }
    void buildStorage() override { m_computer.setStorage("2TB NVMe SSD"); }
    void buildGPU() override { m_computer.setGPU("RTX 4090"); }
    Computer getResult() override { return m_computer; }
    
private:
    Computer m_computer;
};

// 具体建造者 - 办公电脑
class OfficeComputerBuilder : public ComputerBuilder {
public:
    void buildCPU() override { m_computer.setCPU("Intel i5-12400"); }
    void buildRAM() override { m_computer.setRAM("16GB DDR4"); }
    void buildStorage() override { m_computer.setStorage("512GB SSD"); }
    void buildGPU() override { m_computer.setGPU("集成显卡"); }
    Computer getResult() override { return m_computer; }
    
private:
    Computer m_computer;
};

// 指挥者
class Director {
public:
    void setBuilder(ComputerBuilder* builder) { m_builder = builder; }
    
    Computer construct() {
        m_builder->buildCPU();
        m_builder->buildRAM();
        m_builder->buildStorage();
        m_builder->buildGPU();
        return m_builder->getResult();
    }
    
private:
    ComputerBuilder* m_builder;
};

// 使用示例
int main() {
    Director director;
    GamingComputerBuilder gamingBuilder;
    
    director.setBuilder(&gamingBuilder);
    Computer gamingPC = director.construct();
    gamingPC.show();
    
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

class Pizza {
public:
    class Builder;
    
    void show() const {
        std::cout << "披萨: " << m_size << "寸, "
                  << (m_cheese ? "芝士" : "无芝士") << ", "
                  << (m_pepperoni ? "意大利辣香肠" : "无香肠") << "\n";
    }
    
private:
    Pizza(int size) : m_size(size) {}
    
    int m_size;
    bool m_cheese = false;
    bool m_pepperoni = false;
    
    friend class Builder;
};

class Pizza::Builder {
public:
    Builder(int size) : m_pizza(size) {}
    
    Builder& addCheese() {
        m_pizza.m_cheese = true;
        return *this;
    }
    
    Builder& addPepperoni() {
        m_pizza.m_pepperoni = true;
        return *this;
    }
    
    Pizza build() {
        return std::move(m_pizza);
    }
    
private:
    Pizza m_pizza;
};

// 使用
Pizza pizza = Pizza::Builder(12)
    .addCheese()
    .addPepperoni()
    .build();

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

#include <iostream>
#include <unordered_map>
#include <memory>

// 抽象原型
class Prototype {
public:
    virtual ~Prototype() = default;
    virtual std::unique_ptr<Prototype> clone() const = 0;
    virtual void use() const = 0;
};

// 具体原型A
class ConcretePrototypeA : public Prototype {
public:
    ConcretePrototypeA(int data) : m_data(data) {}
    
    // 拷贝构造函数
    ConcretePrototypeA(const ConcretePrototypeA& other)
        : m_data(other.m_data) {}
    
    std::unique_ptr<Prototype> clone() const override {
        return std::make_unique<ConcretePrototypeA>(*this);
    }
    
    void use() const override {
        std::cout << "原型A, 数据: " << m_data << std::endl;
    }
    
private:
    int m_data;
};

// 具体原型B
class ConcretePrototypeB : public Prototype {
public:
    ConcretePrototypeB(const std::string& name) : m_name(name) {}
    
    ConcretePrototypeB(const ConcretePrototypeB& other)
        : m_name(other.m_name) {}
    
    std::unique_ptr<Prototype> clone() const override {
        return std::make_unique<ConcretePrototypeB>(*this);
    }
    
    void use() const override {
        std::cout << "原型B, 名称: " << m_name << std::endl;
    }
    
private:
    std::string m_name;
};

// 原型管理器
class PrototypeManager {
public:
    void registerPrototype(const std::string& key, std::unique_ptr<Prototype> prototype) {
        m_prototypes[key] = std::move(prototype);
    }
    
    std::unique_ptr<Prototype> create(const std::string& key) {
        auto it = m_prototypes.find(key);
        if (it != m_prototypes.end()) {
            return it->second->clone();
        }
        return nullptr;
    }
    
private:
    std::unordered_map<std::string, std::unique_ptr<Prototype>> m_prototypes;
};

// 使用示例
int main() {
    PrototypeManager manager;
    manager.registerPrototype("A", std::make_unique<ConcretePrototypeA>(100));
    manager.registerPrototype("B", std::make_unique<ConcretePrototypeB>("Test"));
    
    auto cloneA = manager.create("A");
    auto cloneB = manager.create("B");
    
    cloneA->use();
    cloneB->use();
    
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

#include <iostream>

// 目标接口
class Target {
public:
    virtual ~Target() = default;
    virtual void request() = 0;
};

// 需要适配的类
class Adaptee {
public:
    void specificRequest() {
        std::cout << "Adaptee的特殊请求" << std::endl;
    }
};

// 适配器
class Adapter : public Target {
public:
    Adapter() : m_adaptee(std::make_unique<Adaptee>()) {}
    
    void request() override {
        m_adaptee->specificRequest();  // 转换调用
    }
    
private:
    std::unique_ptr<Adaptee> m_adaptee;
};

1
2
3
4
5
6

class ClassAdapter : public Target, private Adaptee {
public:
    void request() override {
        specificRequest();  // 直接调用父类方法
    }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

// stack实际上是对deque的适配
template <typename T, typename Container = std::deque<T>>
class Stack {
public:
    void push(const T& value) {
        c.push_back(value);
    }
    
    void pop() {
        c.pop_back();
    }
    
    T& top() {
        return c.back();
    }
    
    bool empty() const {
        return c.empty();
    }
    
private:
    Container c;  // 被适配的容器
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

#include <iostream>
#include <memory>

// 实现接口
class Color {
public:
    virtual ~Color() = default;
    virtual std::string getName() const = 0;
};

// 具体实现A
class Red : public Color {
public:
    std::string getName() const override { return "红色"; }
};

// 具体实现B
class Blue : public Color {
public:
    std::string getName() const override { return "蓝色"; }
};

// 抽象部分
class Shape {
public:
    Shape(std::unique_ptr<Color> color) : m_color(std::move(color)) {}
    virtual ~Shape() = default;
    virtual void draw() = 0;
    
protected:
    std::unique_ptr<Color> m_color;  // 桥接
};

// 扩展抽象A
class Circle : public Shape {
public:
    Circle(std::unique_ptr<Color> color, double radius)
        : Shape(std::move(color)), m_radius(radius) {}
    
    void draw() override {
        std::cout << "画一个" << m_color->getName() 
                  << "的圆形，半径: " << m_radius << std::endl;
    }
    
private:
    double m_radius;
};

// 扩展抽象B
class Rectangle : public Shape {
public:
    Rectangle(std::unique_ptr<Color> color, double width, double height)
        : Shape(std::move(color)), m_width(width), m_height(height) {}
    
    void draw() override {
        std::cout << "画一个" << m_color->getName()
                  << "的矩形，" << m_width << "x" << m_height << std::endl;
    }
    
private:
    double m_width;
    double m_height;
};

// 使用示例
int main() {
    auto red = std::make_unique<Red>();
    auto blue = std::make_unique<Blue>();
    
    Circle redCircle(std::move(red), 5.0);
    Rectangle blueRect(std::move(blue), 10.0, 20.0);
    
    redCircle.draw();
    blueRect.draw();
    
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

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

// 抽象组件
class Component {
public:
    virtual ~Component() = default;
    virtual void display(int depth = 0) const = 0;
    
    virtual void add(std::unique_ptr<Component>) {}
    virtual void remove(Component*) {}
    
protected:
    void printIndent(int depth) const {
        for (int i = 0; i < depth; ++i) {
            std::cout << "  ";
        }
    }
};

// 叶子节点
class Leaf : public Component {
public:
    Leaf(const std::string& name) : m_name(name) {}
    
    void display(int depth = 0) const override {
        printIndent(depth);
        std::cout << "- " << m_name << std::endl;
    }
    
private:
    std::string m_name;
};

// 组合节点
class Composite : public Component {
public:
    Composite(const std::string& name) : m_name(name) {}
    
    void add(std::unique_ptr<Component> component) override {
        m_children.push_back(std::move(component));
    }
    
    void remove(Component* component) override {
        m_children.erase(
            std::remove_if(m_children.begin(), m_children.end(),
                [component](const std::unique_ptr<Component>& c) {
                    return c.get() == component;
                }),
            m_children.end()
        );
    }
    
    void display(int depth = 0) const override {
        printIndent(depth);
        std::cout << "+ " << m_name << std::endl;
        
        for (const auto& child : m_children) {
            child->display(depth + 1);
        }
    }
    
private:
    std::string m_name;
    std::vector<std::unique_ptr<Component>> m_children;
};

// 使用示例 - 文件系统
int main() {
    auto root = std::make_unique<Composite>("根目录");
    
    auto docs = std::make_unique<Composite>("文档");
    docs->add(std::make_unique<Leaf>("readme.txt"));
    docs->add(std::make_unique<Leaf>("todo.md"));
    
    auto pics = std::make_unique<Composite>("图片");
    pics->add(std::make_unique<Leaf>("photo.jpg"));
    
    root->add(std::move(docs));
    root->add(std::move(pics));
    root->add(std::make_unique<Leaf>("config.json"));
    
    root->display();
    
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

#include <iostream>
#include <memory>

// 抽象组件
class Coffee {
public:
    virtual ~Coffee() = default;
    virtual double cost() const = 0;
    virtual std::string description() const = 0;
};

// 具体组件
class SimpleCoffee : public Coffee {
public:
    double cost() const override { return 10.0; }
    std::string description() const override { return "简单咖啡"; }
};

// 装饰器基类
class CoffeeDecorator : public Coffee {
public:
    CoffeeDecorator(std::unique_ptr<Coffee> coffee)
        : m_coffee(std::move(coffee)) {}
    
protected:
    std::unique_ptr<Coffee> m_coffee;
};

// 具体装饰器 - 牛奶
class MilkDecorator : public CoffeeDecorator {
public:
    MilkDecorator(std::unique_ptr<Coffee> coffee)
        : CoffeeDecorator(std::move(coffee)) {}
    
    double cost() const override {
        return m_coffee->cost() + 2.0;
    }
    
    std::string description() const override {
        return m_coffee->description() + " + 牛奶";
    }
};

// 具体装饰器 - 糖
class SugarDecorator : public CoffeeDecorator {
public:
    SugarDecorator(std::unique_ptr<Coffee> coffee)
        : CoffeeDecorator(std::move(coffee)) {}
    
    double cost() const override {
        return m_coffee->cost() + 1.0;
    }
    
    std::string description() const override {
        return m_coffee->description() + " + 糖";
    }
};

// 具体装饰器 - 奶泡
class WhipDecorator : public CoffeeDecorator {
public:
    WhipDecorator(std::unique_ptr<Coffee> coffee)
        : CoffeeDecorator(std::move(coffee)) {}
    
    double cost() const override {
        return m_coffee->cost() + 3.0;
    }
    
    std::string description() const override {
        return m_coffee->description() + " + 奶泡";
    }
};

// 使用示例
int main() {
    // 简单咖啡
    std::unique_ptr<Coffee> coffee = std::make_unique<SimpleCoffee>();
    std::cout << coffee->description() << ": ¥" << coffee->cost() << std::endl;
    
    // 加牛奶
    coffee = std::make_unique<MilkDecorator>(std::move(coffee));
    std::cout << coffee->description() << ": ¥" << coffee->cost() << std::endl;
    
    // 再加糖
    coffee = std::make_unique<SugarDecorator>(std::move(coffee));
    std::cout << coffee->description() << ": ¥" << coffee->cost() << std::endl;
    
    // 再加奶泡
    coffee = std::make_unique<WhipDecorator>(std::move(coffee));
    std::cout << coffee->description() << ": ¥" << coffee->cost() << std::endl;
    
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

#include <iostream>
#include <string>

// 子系统A - 内存管理
class Memory {
public:
    void init() { std::cout << "初始化内存...\n"; }
    void load(const std::string& program) {
        std::cout << "加载程序到内存: " << program << "\n";
    }
    void shutdown() { std::cout << "关闭内存...\n"; }
};

// 子系统B - CPU
class CPU {
public:
    void init() { std::cout << "初始化CPU...\n"; }
    void execute() { std::cout << "CPU执行指令...\n"; }
    void shutdown() { std::cout << "关闭CPU...\n"; }
};

// 子系统C - 硬盘
class HardDrive {
public:
    void init() { std::cout << "初始化硬盘...\n"; }
    std::string readBootSector() { return "操作系统启动代码"; }
    void shutdown() { std::cout << "关闭硬盘...\n"; }
};

// 外观类
class ComputerFacade {
public:
    void start() {
        std::cout << "===== 电脑启动 =====" << std::endl;
        m_hd.init();
        m_memory.init();
        m_cpu.init();
        
        std::string os = m_hd.readBootSector();
        m_memory.load(os);
        m_cpu.execute();
        std::cout << "===== 启动完成 =====" << std::endl;
    }
    
    void stop() {
        std::cout << "===== 电脑关闭 =====" << std::endl;
        m_cpu.shutdown();
        m_memory.shutdown();
        m_hd.shutdown();
        std::cout << "===== 关闭完成 =====" << std::endl;
    }
    
private:
    Memory m_memory;
    CPU m_cpu;
    HardDrive m_hd;
};

// 使用示例
int main() {
    ComputerFacade computer;
    computer.start();
    std::cout << "\n电脑运行中...\n\n";
    computer.stop();
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

#include <iostream>
#include <unordered_map>
#include <memory>
#include <string>

// 享元类
class Character {
public:
    Character(char intrinsicState) : m_symbol(intrinsicState) {}
    
    void display(int extrinsicState) const {  // 外部状态作为参数传入
        std::cout << "字符: '" << m_symbol 
                  << "', 字号: " << extrinsicState << std::endl;
    }
    
    char getSymbol() const { return m_symbol; }
    
private:
    char m_symbol;  // 内部状态：字符本身，可共享
};

// 享元工厂
class CharacterFactory {
public:
    std::shared_ptr<Character> getCharacter(char key) {
        auto it = m_characters.find(key);
        if (it == m_characters.end()) {
            auto character = std::make_shared<Character>(key);
            m_characters[key] = character;
            std::cout << "创建新字符: '" << key << "'\n";
            return character;
        }
        return it->second;
    }
    
    size_t getCount() const { return m_characters.size(); }
    
private:
    std::unordered_map<char, std::shared_ptr<Character>> m_characters;
};

// 使用示例
int main() {
    CharacterFactory factory;
    
    // 文档内容
    std::string document = "Hello World! Hello C++!";
    int fontSize = 12;
    
    std::cout << "渲染文档:\n";
    for (char c : document) {
        auto character = factory.getCharacter(c);
        character->display(fontSize);
        fontSize++;  // 模拟不同的字号（外部状态）
    }
    
    std::cout << "\n享元池中字符数量: " << factory.getCount() << std::endl;
    std::cout << "文档总长度: " << document.size() << std::endl;
    std::cout << "节省了 " << (document.size() - factory.getCount()) 
              << " 个对象\n";
    
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

#include <iostream>
#include <memory>
#include <string>

// 抽象主题
class Image {
public:
    virtual ~Image() = default;
    virtual void display() = 0;
};

// 真实主题
class RealImage : public Image {
public:
    RealImage(const std::string& filename) : m_filename(filename) {
        loadFromDisk();
    }
    
    void display() override {
        std::cout << "显示图片: " << m_filename << std::endl;
    }
    
private:
    void loadFromDisk() {
        std::cout << "从磁盘加载图片: " << m_filename << std::endl;
    }
    
    std::string m_filename;
};

// 代理
class ImageProxy : public Image {
public:
    ImageProxy(const std::string& filename) : m_filename(filename) {}
    
    void display() override {
        if (!m_realImage) {
            m_realImage = std::make_unique<RealImage>(m_filename);
        }
        m_realImage->display();
    }
    
private:
    std::string m_filename;
    std::unique_ptr<RealImage> m_realImage;
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

#include <iostream>
#include <string>

// 抽象主题
class Database {
public:
    virtual ~Database() = default;
    virtual void query(const std::string& sql) = 0;
};

// 真实主题
class RealDatabase : public Database {
public:
    void query(const std::string& sql) override {
        std::cout << "执行SQL: " << sql << std::endl;
    }
};

// 代理
class DatabaseProxy : public Database {
public:
    DatabaseProxy(const std::string& user, const std::string& password)
        : m_user(user), m_password(password) {}
    
    void query(const std::string& sql) override {
        if (checkAccess()) {
            if (!m_realDB) {
                m_realDB = std::make_unique<RealDatabase>();
            }
            logQuery(sql);
            m_realDB->query(sql);
        } else {
            std::cout << "访问被拒绝！\n";
        }
    }
    
private:
    bool checkAccess() {
        return m_user == "admin" && m_password == "123456";
    }
    
    void logQuery(const std::string& sql) {
        std::cout << "[日志] 用户 " << m_user << " 执行查询: " << sql << "\n";
    }
    
    std::string m_user;
    std::string m_password;
    std::unique_ptr<RealDatabase> m_realDB;
};

1
2
3
4
5
6
7
8
9

// std::shared_ptr 就是一种代理模式
#include <memory>

class MyClass {};

void example() {
    std::shared_ptr<MyClass> ptr = std::make_shared<MyClass>();
    // ptr 代理了 MyClass 对象，控制其生命周期和访问
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102

#include <iostream>
#include <memory>
#include <string>

// 请求
class Request {
public:
    Request(const std::string& type, int level)
        : m_type(type), m_level(level) {}
    
    std::string getType() const { return m_type; }
    int getLevel() const { return m_level; }
    
private:
    std::string m_type;
    int m_level;
};

// 抽象处理者
class Handler {
public:
    virtual ~Handler() = default;
    
    void setNext(std::shared_ptr<Handler> next) {
        m_next = std::move(next);
    }
    
    void handle(const Request& request) {
        if (canHandle(request)) {
            process(request);
        } else if (m_next) {
            m_next->handle(request);
        } else {
            std::cout << "无人能处理该请求！\n";
        }
    }
    
protected:
    virtual bool canHandle(const Request& request) = 0;
    virtual void process(const Request& request) = 0;
    
    std::shared_ptr<Handler> m_next;
};

// 具体处理者A - 低级支持
class Level1Support : public Handler {
protected:
    bool canHandle(const Request& request) override {
        return request.getLevel() <= 1;
    }
    
    void process(const Request& request) override {
        std::cout << "一级支持处理请求: " << request.getType() << "\n";
    }
};

// 具体处理者B - 中级支持
class Level2Support : public Handler {
protected:
    bool canHandle(const Request& request) override {
        return request.getLevel() <= 2;
    }
    
    void process(const Request& request) override {
        std::cout << "二级支持处理请求: " << request.getType() << "\n";
    }
};

// 具体处理者C - 高级支持
class Level3Support : public Handler {
protected:
    bool canHandle(const Request& request) override {
        return request.getLevel() <= 3;
    }
    
    void process(const Request& request) override {
        std::cout << "三级支持处理请求: " << request.getType() << "\n";
    }
};

// 使用示例
int main() {
    auto level1 = std::make_shared<Level1Support>();
    auto level2 = std::make_shared<Level2Support>();
    auto level3 = std::make_shared<Level3Support>();
    
    // 构建责任链
    level1->setNext(level2);
    level2->setNext(level3);
    
    Request req1("简单问题", 1);
    Request req2("中等问题", 2);
    Request req3("复杂问题", 3);
    Request req4("未知问题", 4);
    
    level1->handle(req1);
    level1->handle(req2);
    level1->handle(req3);
    level1->handle(req4);
    
    return 0;
}