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

😏★,°:.☆(￣▽￣)/$:.°★ 😏
这篇文章主要介绍设计模式：观察者、策略、模板。
学其所用，用其所学。——梁启超
欢迎来到我的博客，一起学习，共同进步。
喜欢的朋友可以关注一下，下次更新不迷路🥞

文章目录

- :smirk:1. 观察者模式
- :blush:2. 策略模式
- :satisfied:3. 模板方法

😏1. 观察者模式

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

#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. 策略模式

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

#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）是一种行为型设计模式，它定义了一个操作中的算法的骨架，而将一些步骤延迟到子类中。这样可以使子类在不改变算法结构的情况下重新定义某些步骤。

#include <iostream>// 抽象类定义模板方法
class AbstractClass {
public:// 模板方法定义了算法的骨架void templateMethod() {step1();step2();step3();}virtual void step1() = 0; // 子类必须实现的步骤1virtual void step2() = 0; // 子类必须实现的步骤2void 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;
}