【C++】设计模式：观察者、策略、模板

😏★,° :.☆(￣▽￣)/$:.°★ 😏

这篇文章主要介绍设计模式：观察者、策略、模板。
学其所用，用其所学。------梁启超

欢迎来到我的博客，一起学习，共同进步。

喜欢的朋友可以关注一下，下次更新不迷路🥞

文章目录

- [:smirk:1. 观察者模式](#:smirk:1. 观察者模式)
- [:blush:2. 策略模式](#:blush:2. 策略模式)
- [:satisfied:3. 模板方法](#:satisfied:3. 模板方法)

😏1. 观察者模式

观察者模式的基本原理，通过观察者模式可以实现对象之间的松耦合，当一个对象的状态发生变化时，所有依赖于它的对象都会得到通知并作出相应的响应。

cpp 复制代码

#include <iostream>
#include <vector>

// 观察者基类
class Observer {
public:
    virtual void update(int data) = 0;
};

// 具体观察者类 A
class ConcreteObserverA : public Observer {
public:
    void update(int data) override {
        std::cout << "Concrete Observer A received data: " << data << std::endl;
    }
};

// 具体观察者类 B
class ConcreteObserverB : public Observer {
public:
    void update(int data) override {
        std::cout << "Concrete Observer B received data: " << data << std::endl;
    }
};

// 主题类
class Subject {
private:
    int data;
    std::vector<Observer*> observers;

public:
    void attach(Observer* observer) {
        observers.push_back(observer);
    }

    void setData(int newData) {
        data = newData;
        notify();
    }

    void notify() {
        for (Observer* observer : observers) {
            observer->update(data);
        }
    }
};

int main() {
    ConcreteObserverA observerA;
    ConcreteObserverB observerB;

    Subject subject;
    subject.attach(&observerA);
    subject.attach(&observerB);

    subject.setData(100);

    return 0;
}

😊2. 策略模式

策略模式是一种行为设计模式，它允许在运行时选择算法的行为。定义一系列算法，把它们封装起来，并且使它们可以互相替换。策略模式可以使算法独立于使用它的客户端而变化。

cpp 复制代码

#include <iostream>

// 策略接口
class Strategy {
public:
    virtual void execute() = 0;
};

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

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

// 上下文类
class Context {
private:
    Strategy* strategy;

public:
    Context(Strategy* s) : strategy(s) {}

    void setStrategy(Strategy* s) {
        strategy = s;
    }

    void executeStrategy() {
        strategy->execute();
    }
};

int main() {
    ConcreteStrategyA strategyA;
    ConcreteStrategyB strategyB;

    Context context(&strategyA);
    context.executeStrategy();

    context.setStrategy(&strategyB);
    context.executeStrategy();

    return 0;
}

😆3. 模板方法

模板方法模式（Template Method Pattern）是一种行为型设计模式，它定义了一个操作中的算法的骨架，而将一些步骤延迟到子类中。这样可以使子类在不改变算法结构的情况下重新定义某些步骤。

cpp 复制代码

#include <iostream>

// 抽象类定义模板方法
class AbstractClass {
public:
    // 模板方法定义了算法的骨架
    void templateMethod() {
        step1();
        step2();
        step3();
    }

    virtual void step1() = 0; // 子类必须实现的步骤1
    virtual void step2() = 0; // 子类必须实现的步骤2

    void step3() {
        std::cout << "Abstract step3" << std::endl;
    }
};

// 具体子类实现具体步骤
class ConcreteClassA : public AbstractClass {
public:
    void step1() override {
        std::cout << "ConcreteClassA step1" << std::endl;
    }

    void step2() override {
        std::cout << "ConcreteClassA step2" << std::endl;
    }
};

class ConcreteClassB : public AbstractClass {
public:
    void step1() override {
        std::cout << "ConcreteClassB step1" << std::endl;
    }

    void step2() override {
        std::cout << "ConcreteClassB step2" << std::endl;
    }
};

int main() {
    AbstractClass* a = new ConcreteClassA();
    AbstractClass* b = new ConcreteClassB();

    a->templateMethod();
    b->templateMethod();

    delete a;
    delete b;

    return 0;
}

通过模板方法模式，我们可以在父类中定义一个算法的骨架，而将具体实现延迟到子类中，从而实现代码复用和扩展。

以上。