设计模式（C++）

todaycode

已于 2023-04-27 22:28:18 修改

阅读量208

点赞数

分类专栏： C++ 文章标签：设计模式

于 2023-04-19 21:25:14 首次发布

本文链接：https://blog.csdn.net/qq_43337263/article/details/130252983

版权

C++ 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

1 绪论

设计模式，是一套被反复使用的代码设计经验的总结，是经过提炼的出色设计方法。
设计模式，是程序员在长期的开发实践中总结出的一套提高开发效率与程序执行效率的编程方法。
设计模式，代表了一些解决常见问题的通用做法，体现着人们尝试解决某些问题时的智慧。所以，它是一种强大的管理复杂度的工具。
设计模式，是在特定问题发生时的可重用解决方案。

设计模式在比编程语言惯用手法更高的层面来描述解决特定类型问题的途径。
设计模式用来描述在软件系统中如何通过管理代码的相互依赖性来管理复杂性。

一个设计模式用来描述几个模块或类对象之间关系、职责，以及它们之间如何进行分工与合作。
一个甚至是几个设计模式共同配合来解决软件设计中面对的实际问题。

2 面向对象设计原则

a 单一职责原则

类的职责单一，对外只提供一种功能，而引起类变化的原因都应该只有一个。

b 开闭原则

类的改动是通过增加代码进行的，而不是修改源代码。

c 里氏替换原则(多态)

任何抽象类出现的地方都可以用他的实现类进行替换，实际就是虚拟机制，语言级别实现面向对象功能。

d 依赖倒转原则

依赖于抽象(接口)，不要依赖具体的实现(类)，也就是针对接口编程。

e 合成复用原则

对于继承和组合，优先使用组合

f 迪米特法则

一个对象应当对其他对象尽可能少的了解，从而降低各个对象之间的耦合，提高系统的可维护性。例如在一个程序中，各个模块之间相互调用时，通常会提供一个统一的接口来实现。这样其他模块不需要了解另外一个模块的内部实现细节，这样当一个模块内部的实现发生改变时，不会影响其他模块的使用。（黑盒原理)

3 具体模式

a 模板方法（Template Method）

#include <iostream>
using namespace std;

class Fighter
{
public:
	Fighter(int life, int magic, int attack) 
		: m_life(life)
		, m_magic(magic)
		, m_attack(attack)
	{

	}
	virtual ~Fighter() {}

	void JN_Burn()  //技能燃烧
	{
		effect_enemy();
		effect_self();
		play_effect();
	}

protected:
	int m_life;
	int m_magic;
	int m_attack;

private:
	virtual void effect_enemy() {}
	virtual void effect_self() {}
	void play_effect() 
	{
		cout << "播放燃烧技能..." << endl;
	}
};

class F_Warrior : public Fighter
{
public:
	F_Warrior(int life, int magic, int attack)
		: Fighter(life, magic, attack)
	{

	}

private:
	virtual void effect_enemy() 
	{
		cout << "战士_让所以敌人失去500点生命值..." << endl;
	}
	virtual void effect_self() 
	{
		m_life -= 300;
		cout << "战士_失去300生命值..." << endl;
	}
};

class F_Mage : public Fighter
{
public:
	F_Mage(int life, int magic, int attack)
		: Fighter(life, magic, attack)
	{

	}

private:
	virtual void effect_enemy()
	{
		cout << "法师_让所以敌人失去650点生命值..." << endl;
	}
	virtual void effect_self()
	{
		m_life -= 100;
		cout << "战士_失去100生命值..." << endl;
	}
};
int main()
{
	Fighter* prole_war = new F_Warrior(1000, 0, 200);
	prole_war->JN_Burn();

	cout << "----------------------" << endl;

	Fighter* prole_mag = new F_Mage(800, 200, 300);
	prole_mag->JN_Burn();

	return 0;
}

b 策略（Strategy）

#include <iostream>
using namespace std;

//抽象的武器策略
class Weaponstrategy
{
public:
	virtual void useWeapon() = 0;
};

class Kinfe : public Weaponstrategy
{
public:
	virtual void useWeapon()
	{
		cout << "使用匕首!" << endl;
	}
};

class AK47 : public Weaponstrategy
{
public:
	virtual void useWeapon()
	{
		cout << "使用AK47!" << endl;
	}
};

class CharActer
{
public:
	void seaWeapon(Weaponstrategy* pWeapon)
	{
		m_pWeapon = pWeapon;
	}

	void ThrowWeapon()
	{
		m_pWeapon->useWeapon();
	}

private:
	Weaponstrategy* m_pWeapon;
};

int main()
{
	CharActer* people = new CharActer();

	Weaponstrategy* pWeapon1 = new Kinfe();
	Weaponstrategy* pWeapon2 = new AK47();

	people->seaWeapon(pWeapon1);
	people->ThrowWeapon();

	people->seaWeapon(pWeapon2);
	people->ThrowWeapon();

	return 0;
}

c 观察者（Observer）

#include <list>
#include <iostream>
using namespace std;

//抽象的观察者
class AbstractHero
{
public:
	virtual void update() = 0;
protected:
private:
};

//观察者A
class HerA : public AbstractHero
{
public:
	HerA()
	{
		cout << "英雄A正在攻击BOSS" << endl;
	}

	virtual void update()
	{
		cout << "英雄A停止撸，待机状态..." << endl;
	}
};

//观察者B
class HerB : public AbstractHero
{
public:
	HerB()
	{
		cout << "英雄B正在攻击BOSS" << endl;
	}
	virtual void update()
	{
		cout << "英雄B停止撸，待机状态..." << endl;
	}
};

//观察者C
class HerC : public AbstractHero
{
public:
	HerC()
	{
		cout << "英雄C正在攻击BOSS" << endl;
	}
	virtual void update()
	{
		cout << "英雄C停止撸，待机状态..." << endl;
	}
};

//被观察目标抽象
class AbstractBoss
{
public:
	virtual void addHero(AbstractHero* pHero) = 0;
	virtual void delHero(AbstractHero* pHero) = 0;
	virtual void notify() = 0;  //通知所有观察者
};

//具体的被观察者 BOSS_A
class BossA : public AbstractBoss
{
public:
	virtual void addHero(AbstractHero* pHero)
	{
		m_pHeroList.push_back(pHero);
	}
	virtual void delHero(AbstractHero* pHero)
	{
		m_pHeroList.remove(pHero);
	}
	virtual void notify()
	{
		for (list<AbstractHero*>::iterator iter = m_pHeroList.begin(); iter != m_pHeroList.end(); ++iter)
		{
			(*iter)->update();
		}
	}

private:
	list<AbstractHero*> m_pHeroList;
};

int main()
{
	//创建观察者
	AbstractHero* pHeroA = new HerA();
	AbstractHero* pHeroB = new HerB();
	AbstractHero* pHeroC = new HerC();

	//创建被观察者
	AbstractBoss* pBoss = new BossA();
	
	pBoss->addHero(pHeroA);
	pBoss->addHero(pHeroB);
	pBoss->addHero(pHeroC);

	pBoss->delHero(pHeroC);
	cout << "英雄C阵亡..." << endl;

	pBoss->notify();
	cout << "Boss死了，通知其他英雄停止攻击..." << endl;
	return 0;
}

输出

英雄A正在攻击BOSS
英雄B正在攻击BOSS
英雄C正在攻击BOSS
英雄C阵亡...
英雄A停止撸，待机状态...
英雄B停止撸，待机状态...
Boss死了，通知其他英雄停止攻击...

d 命令（Command）

e 迭代器（Iterator）

f 状态（State）

g 中介者（Mediator）

h 备忘录（Memento）

i 职责链（Chain of Responsibility）

j 访问者（Visitor）

k 解释器（Interpreter）

L 简单工厂（Simple Factory）

M 工厂方法（Factory Method）

N 抽象工厂（Abstract Factory）

o 原型（Prototype）

p 建造者（Builder）

q 单件（Singleton）

r 装饰（Decorator）

版本Ⅰ

#include <iostream>
using namespace std;

//抽象的控件类
class Control
{
public:
	virtual void draw() = 0;
	virtual ~Control() {};
};

//列表控件类
class ListCtrl : public Control
{
public:
	virtual void draw()
	{
		cout << "绘制普通的列表控件!" << endl;
	}
};

//抽象的装饰器类
class Decorator : public Control
{
public:
	Decorator(Control* pControl)
		: m_pControl(pControl)
	{

	}

	virtual void draw()
	{
		m_pControl->draw();
	}

private:
	Control * m_pControl;
};

//具体的“边框”装饰器类
class BorderDec : public Decorator
{
public:
	BorderDec(Control* pControl)
		: Decorator(pControl)
	{

	}

	virtual void draw()
	{
		Decorator::draw();
		drawBorder();
	}

private:
	void drawBorder()
	{
		cout << "绘制边框!" << endl;
	}
};

//具体的“垂直滚动条”装饰器类
class VerScrollBarDec : public Decorator
{
public:
	VerScrollBarDec(Control* pControl)
		: Decorator(pControl)
	{

	}

	virtual void draw()
	{
		Decorator::draw();
		drawVerScrollBar();
	}

private:
	void drawVerScrollBar()
	{
		cout << "绘制垂直滚动条!" << endl;
	}
};

//具体的“水平滚动条”装饰器
class HorScrollBarDec : public Decorator
{
public:
	HorScrollBarDec(Control* pControl)
		: Decorator(pControl)
	{

	}

	virtual void draw()
	{
		Decorator::draw();
		drawHorScrollBar();
	}

private:
	void drawHorScrollBar()
	{
		cout << "绘制水平滚动条!" << endl;
	}
};

int main()
{
	Control* pControl = new ListCtrl();  //裸控件
	Decorator* pControl_b = new BorderDec(pControl);  //裸控件+边框
	Decorator* pControl_b_v = new VerScrollBarDec(pControl_b);  //裸控件+边框+垂直滚动条
	pControl_b_v->draw();
	return 0;
}

输出：

绘制普通的列表控件!
绘制边框!
绘制垂直滚动条!

版本Ⅱ

#include "stdafx.h"
#include <iostream>
using namespace std;

//一般情况下，用继承实现类的功能拓展
//装饰模式 可以动态给一个类增加功能

//抽象英雄
class AbstractHero 
{
public:
    virtual void ShowStatus() = 0;
public:
    int mHp;
    int mMp;
    int mAt;
    int mDf;
};

//具体英雄
class HeroA :public AbstractHero 
{
public:
    HeroA() 
    {
        mHp = 0;
        mMp = 0;
        mAt = 0;
        mDf = 0;
    }
    virtual void ShowStatus() 
    {
        cout << "血量：" << mHp << endl;
        cout << "魔法：" << mMp << endl;
        cout << "攻击：" << mAt << endl;
        cout << "防御：" << mDf << endl;
    }
};

//英雄穿上某个装饰物 那么他还是个英雄
//装饰物
class AbstractEquipmet : public AbstractHero 
{
public:
    AbstractEquipmet(AbstractHero* hero) 
    {
        this->pHero = hero;
    }
    virtual void ShowStatus() = 0;

public:
    AbstractHero * pHero;

};

//狂徒
class KuangtuEquipment :public AbstractEquipmet 
{
public:
    KuangtuEquipment(AbstractHero* hero) :AbstractEquipmet(hero) {}
    //增加额外的功能
    void AddKuangtu() 
    {
        cout << "英雄穿上狂徒之后..." << endl;
        this->mHp = this->pHero->mHp;
        this->mMp = this->pHero->mMp;
        this->mAt = this->pHero->mAt;
        this->mDf = this->pHero->mDf + 30;

        delete this->pHero;
    }
    virtual void ShowStatus() 
    {
        AddKuangtu();
        cout << "血量：" << mHp << endl;
        cout << "魔法：" << mMp << endl;
        cout << "攻击：" << mAt << endl;
        cout << "防御：" << mDf << endl;
    }
};

//无尽
class Wujing : public AbstractEquipmet {
public:
    Wujing(AbstractHero* hero) :AbstractEquipmet(hero) {}
    //增加额外的功能
    void AddWujing() 
    {
        cout << "英雄穿上无尽之后..." << endl;
        this->mHp = this->pHero->mHp;
        this->mMp = this->pHero->mMp;
        this->mAt = this->pHero->mAt + 80;
        this->mDf = this->pHero->mDf;

        delete this->pHero;
    }
    virtual void ShowStatus() 
    {
        AddWujing();
        cout << "血量：" << mHp << endl;
        cout << "魔法：" << mMp << endl;
        cout << "攻击：" << mAt << endl;
        cout << "防御：" << mDf << endl;
    }
};


void test01() 
{
    AbstractHero* hero = new HeroA;
    hero->ShowStatus();
    cout << "----------------------------" << endl;

    //给裸奔的英雄穿上衣服后
    hero = new KuangtuEquipment(hero);
    hero->ShowStatus();

    cout << "----------------------------" << endl;

    //装备武器
    hero = new Wujing(hero);
    hero->ShowStatus();

}
int main() {
    test01();
    return 0;
}

s 外观（facade）

t 组合（Composite）

u 享元（Flyweight）

v 代理（Proxy）

#include <iostream>
using namespace std;

//提供一种代理来控制对其他对象的访问
class AbstractCommonInterface
{
public:
    virtual void run() = 0;
};

class MySystem : public AbstractCommonInterface
{
public:
    virtual void run()
    {
        cout << "系统系统启动..." << endl;
    }
};

//必须有权限验证
class MySystemProxy : public AbstractCommonInterface
{
public:
    MySystemProxy(string userName, string userPassword)
        : m_strUserName(userName)
        , m_strUserPassword(userPassword)
        , m_pMySystem(NULL)
    {
        m_pMySystem = new MySystem;
    }

    virtual void run()
    {
        if (checkUserAuth())
        {
            m_pMySystem->run();
        }
        else
        {
            cout << "用户名或密码错误，无法启动..." << endl;
        }
    }

protected:
    bool checkUserAuth()
    {
        if (m_strUserName == "admin" && m_strUserPassword == "admin")
        {
            return true;
        }
        return false;
    }


private:
    string		m_strUserName;
    string		m_strUserPassword;
    MySystem*   m_pMySystem;
};

int main()
{
	MySystemProxy* pProxy = new MySystemProxy("", "admin");
    pProxy->run();
    return 0;
}

w 适配器（Adapter）

#include <iostream>
using namespace std;

class Fighter
{
public:
	Fighter(int life, int magic, int attack) 
		: m_life(life)
		: m_magic(magic)
		: m_attack(attack)
	{

	}
	virtual ~Fighter() {}

	void JN_Burn()  //技能燃烧
	{
		effect_enemy();
		effect_self();
		play_effect();
	}

protected:
	int m_life;
	int m_magic;
	int m_attack;

private:
	virtual void effect_enemy() {}
	virtual void effect_self() {}
	void play_effect() 
	{
		cout << "播放燃烧技能..." << endl;
	}
};

class F_Warrior : public Fighter
{
public:
	F_Warrior(int life, int magic, int attack)
		: Fighter(life, magic, attack)
	{

	}

private:
	virtual void effect_enemy() 
	{
		cout << "战士_让所以敌人失去500点生命值..." << endl;
	}
	virtual void effect_self() 
	{
		m_life -= 300;
		cout << "战士_失去300生命值..." << endl;
	}
};

class F_Mage : public Fighter
{
public:
	F_Mage(int life, int magic, int attack)
		: Fighter(life, magic, attack)
	{

	}

private:
	virtual void effect_enemy()
	{
		cout << "法师_让所以敌人失去650点生命值..." << endl;
	}
	virtual void effect_self()
	{
		m_life -= 100;
		cout << "战士_失去100生命值..." << endl;
	}
};
int main()
{
	Fighter* prole_war = new F_Warrior(1000, 0, 200);
	prole_war->JN_Burn();

	cout << "----------------------" << endl;

	Fighter* prole_mag = new F_Mage(800, 200, 300);
	prole_mag->JN_Burn();

	return 0;
}

x 桥接（Bridge）

todaycode

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
设计模式（C++）

一个对象应当对其他对象尽可能少的了解，从而降低各个对象之间的耦合，提高系统的可维护性。例如在一个程序中，各个模块之间相互调用时，通常会提供一个统一的接口来实现。这样其他模块不需要了解另外一个模块的内部实现细节，这样当一个模块内部的实现发生改变时，不会影响其他模块的使用。任何抽象类出现的地方都可以用他的实现类进行替换，实际就是虚拟机制，语言级别实现面向对象功能。类的职责单一，对外只提供一种功能，而引起类变化的原因都应该只有一个。依赖于抽象(接口)，不要依赖具体的实现(类)，也就是针对接口编程。
复制链接

扫一扫