😏*★,°* :.☆( ̄▽ ̄)/$:.°★ 😏
这篇文章主要介绍设计模式:观察者、策略、模板。
学其所用,用其所学。------梁启超欢迎来到我的博客,一起学习,共同进步。
喜欢的朋友可以关注一下,下次更新不迷路🥞
文章目录
-
- [: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;
}
通过模板方法模式,我们可以在父类中定义一个算法的骨架,而将具体实现延迟到子类中,从而实现代码复用和扩展。
以上。