XMD

无语

C++设计模式

发表于 更新于 分类于 ，
本文字数： 8.1k 阅读时长 ≈ 7 分钟

工厂模式

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>
using namespace std;

// 抽象产品类
class Product {
public:
    virtual void display() = 0;
};

// 具体产品类 A
class ConcreteProductA : public Product {
public:
    void display() override {
        cout << "This is product A" << endl;
    }
};

// 具体产品类 B
class ConcreteProductB : public Product {
public:
    void display() override {
        cout << "This is product B" << endl;
    }
};

// 工厂接口
class Factory {
public:
    virtual Product* createProduct() = 0;
};

// 具体工厂类 A
class ConcreteFactoryA : public Factory {
public:
    Product* createProduct() override {
        return new ConcreteProductA();
    }
};

// 具体工厂类 B
class ConcreteFactoryB : public Factory {
public:
    Product* createProduct() override {
        return new ConcreteProductB();
    }
};

int main() {
    // 使用具体工厂类 A 创建产品 A
    Factory* factoryA = new ConcreteFactoryA();
    Product* productA = factoryA->createProduct();
    productA->display();

    // 使用具体工厂类 B 创建产品 B
    Factory* factoryB = new ConcreteFactoryB();
    Product* productB = factoryB->createProduct();
    productB->display();

    delete factoryA;
    delete productA;
    delete factoryB;
    delete productB;

    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
#include <iostream>
using namespace std;

// 单例类
class Singleton {
public:
    // 获取单例实例的静态方法
    static Singleton* getInstance() {
        if (!instance) {
            instance = new Singleton();
        }
        return instance;
    }

    // 示例方法
    void showMessage() {
        cout << "Hello, this is the Singleton instance." << endl;
    }

private:
    // 私有化构造函数和拷贝构造函数，禁止外部创建对象实例和复制实例
    Singleton() {}
    Singleton(const Singleton&);
    static Singleton* instance;  // 静态成员变量保存单例实例
};

Singleton* Singleton::instance = nullptr;  // 初始化静态成员变量

int main() {
    // 获取单例实例并调用示例方法
    Singleton* singleton = Singleton::getInstance();
    singleton->showMessage();

    return 0;
}

这是一个简单的 C++ 单例模式示例。在该示例中，我们定义了 Singleton 类，其中包含一个私有的静态成员变量 instance 用于保存单例实例，以及一个公有的静态方法 getInstance 用于获取单例实例。在 main 函数中，我们通过 getInstance 方法获取单例实例，并调用其示例方法 showMessage。注意，为了确保单例模式的唯一性，我们私有化了构造函数和拷贝构造函数，以防止外部直接创建对象实例或复制实例。

适配器模式

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
#include <iostream>
using namespace std;

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

// 适配者类（Adaptee）
class Adaptee {
public:
    void specificRequest() {
        cout << "Adaptee's specific request." << endl;
    }
};

// 类适配器
class ClassAdapter : public Target, private Adaptee {
public:
    void request() override {
        specificRequest();
    }
};

// 对象适配器
class ObjectAdapter : public Target {
private:
    Adaptee* adaptee;
public:
    ObjectAdapter(Adaptee* a) : adaptee(a) {}
    void request() override {
        adaptee->specificRequest();
    }
};

int main() {
    // 类适配器示例
    Target* classAdapter = new ClassAdapter();
    classAdapter->request();

    // 对象适配器示例
    Adaptee* adaptee = new Adaptee();
    Target* objectAdapter = new ObjectAdapter(adaptee);
    objectAdapter->request();

    delete classAdapter;
    delete objectAdapter;
    delete adaptee;

    return 0;
}

这是一个简单的 C++ 适配器模式示例。在该示例中，我们定义了目标接口 Target 和适配者类 Adaptee。然后我们实现了适配器模式的两种形式：类适配器和对象适配器。在 main 函数中，演示了如何分别使用类适配器和对象适配器来调用适配者的方法。通过适配器模式，客户端可以调用目标接口的方法，而适配器内部则负责将请求转发给适配者的方法。

观察者模式

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
#include <iostream>
#include <vector>
using namespace std;

// 观察者基类
class Observer {
public:
    virtual void update(const string& message) = 0;
};

// 具体观察者 A
class ConcreteObserverA : public Observer {
public:
    void update(const string& message) override {
        cout << "ConcreteObserverA received: " << message << endl;
    }
};

// 具体观察者 B
class ConcreteObserverB : public Observer {
public:
    void update(const string& message) override {
        cout << "ConcreteObserverB received: " << message << endl;
    }
};

// 主题接口
class Subject {
public:
    virtual void attach(Observer* observer) = 0;
    virtual void detach(Observer* observer) = 0;
    virtual void notify(const string& message) = 0;
};

// 具体主题
class ConcreteSubject : public Subject {
private:
    vector<Observer*> observers;
public:
    void attach(Observer* observer) override {
        observers.push_back(observer);
    }

    void detach(Observer* observer) override {
        for (auto it = observers.begin(); it != observers.end(); ++it) {
            if (*it == observer) {
                observers.erase(it);
                break;
            }
        }
    }

    void notify(const string& message) override {
        for (const auto& observer : observers) {
            observer->update(message);
        }
    }
};

int main() {
    // 创建具体主题和具体观察者
    ConcreteSubject subject;
    ConcreteObserverA observerA;
    ConcreteObserverB observerB;

    // 添加观察者到主题
    subject.attach(&observerA);
    subject.attach(&observerB);

    // 发送通知
    subject.notify("Hello, this is a notification.");

    // 移除观察者 B
    subject.detach(&observerB);

    // 再次发送通知
    subject.notify("Second notification.");

    return 0;
}

这是一个简单的 C++ 观察者模式示例。在该示例中，我们定义了观察者基类 Observer 和具体观察者类 ConcreteObserverA 和 ConcreteObserverB，以及主题接口 Subject 和具体主题类 ConcreteSubject。在 main 函数中，我们创建了具体主题和具体观察者，并演示了如何将观察者添加到主题、发送通知以及移除观察者的过程。当主题状态发生变化时，所有注册的观察者都会收到相应的通知并执行相应的更新操作。

策略模式

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
#include <iostream>
using namespace std;

// 抽象策略类
class Strategy {
public:
    virtual void execute() = 0;
};

// 具体策略类 A
class ConcreteStrategyA : public Strategy {
public:
    void execute() override {
        cout << "Executing strategy A" << endl;
    }
};

// 具体策略类 B
class ConcreteStrategyB : public Strategy {
public:
    void execute() override {
        cout << "Executing strategy B" << endl;
    }
};

// 上下文类
class Context {
private:
    Strategy* strategy;
public:
    void setStrategy(Strategy* s) {
        strategy = s;
    }

    void executeStrategy() {
        if (strategy) {
            strategy->execute();
        } else {
            cout << "No strategy set" << endl;
        }
    }
};

int main() {
    // 创建上下文对象
    Context context;

    // 使用具体策略 A
    ConcreteStrategyA strategyA;
    context.setStrategy(&strategyA);
    context.executeStrategy();

    // 切换到具体策略 B
    ConcreteStrategyB strategyB;
    context.setStrategy(&strategyB);
    context.executeStrategy();

    return 0;
}

这是一个简单的 C++ 策略模式示例。在该示例中，我们定义了抽象策略类 Strategy 和两个具体策略类 ConcreteStrategyA 和 ConcreteStrategyB，以及上下文类 Context。在 main 函数中，我们创建了上下文对象，并演示了如何使用不同的具体策略来执行特定的操作。通过策略模式，客户端可以在运行时动态地切换不同的策略，而不需要修改原有的上下文代码。

装饰器模式

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
#include <iostream>
using namespace std;

// 抽象组件类
class Component {
public:
    virtual void operation() = 0;
};

// 具体组件类
class ConcreteComponent : public Component {
public:
    void operation() override {
        cout << "This is the original operation." << endl;
    }
};

// 抽象装饰器类
class Decorator : public Component {
protected:
    Component* component;
public:
    Decorator(Component* c) : component(c) {}
    void operation() override {
        if (component) {
            component->operation();
        }
    }
};

// 具体装饰器类 A
class ConcreteDecoratorA : public Decorator {
public:
    ConcreteDecoratorA(Component* c) : Decorator(c) {}
    void addBehavior() {
        cout << "Added behavior from decorator A." << endl;
    }
    void operation() override {
        Decorator::operation();
        addBehavior();
    }
};

// 具体装饰器类 B
class ConcreteDecoratorB : public Decorator {
public:
    ConcreteDecoratorB(Component* c) : Decorator(c) {}
    void addExtraBehavior() {
        cout << "Added extra behavior from decorator B." << endl;
    }
    void operation() override {
        Decorator::operation();
        addExtraBehavior();
    }
};

int main() {
    // 创建具体组件对象
    Component* component = new ConcreteComponent();

    // 使用装饰器 A 对组件进行装饰
    Decorator* decoratorA = new ConcreteDecoratorA(component);
    decoratorA->operation();

    // 使用装饰器 B 对组件进行装饰
    Decorator* decoratorB = new ConcreteDecoratorB(component);
    decoratorB->operation();

    delete component;
    delete decoratorA;
    delete decoratorB;

    return 0;
}

这是一个简单的 C++ 装饰器模式示例。在该示例中，我们定义了抽象组件类 Component 和具体组件类 ConcreteComponent，以及抽象装饰器类 Decorator 和两个具体装饰器类 ConcreteDecoratorA 和 ConcreteDecoratorB。在 main 函数中，我们创建了具体组件对象，并使用不同的装饰器对其进行装饰。通过装饰器模式，可以动态地扩展对象的功能，同时避免了使用继承带来的静态特性和多子类衍生问题。

-------------本文结束感谢您的阅读-------------

相关文章