常用设计模式

一、简单工厂模式：

优点：

1、客户端和具体实现类解耦

2、对于某些对象创建过程过于复杂的情况我们不用去做考虑

缺点：

1、简单工厂模式，增加新的工程是通过修改源代码实现，不符合开闭原则。

2、这个类的职责过重，这个类一旦发生问题，会影响很多使用该工厂的模块。

代码实现：

#include<iostream>
using namespace std;
class Abfruit
{
public:
	virtual void showname() = 0;
};
class Apple : public  Abfruit
{
public:
	virtual void showname()
	{
		cout << "这是苹果" << endl;
	}
};
class Banner : public  Abfruit
{
public:
	virtual void showname()
	{
		cout << "这是香蕉" << endl;
	}
};
class Fiactory
{
public:
	static Abfruit* setFruit(string fruit)
	{
		if (fruit == "Apple")
		{
			return new Apple;
		}
		else if (fruit == "Banner")
		{
			return new Banner;
		}
		else
		{
			return nullptr;
		}
	}
};

int main()
{
	Abfruit* afruit = Fiactory::setFruit("Apple");
	afruit->showname();
	delete afruit;
	afruit = Fiactory::setFruit("Banner");
	afruit->showname();
	delete afruit;
}

适用场景：

1、工厂类负责创建的对象比较少，由于的对象比较少，不会造成工厂方法中的业务逻辑太过复杂

2、客户端只知道传入工厂类的参数，对于如何创建对象并不关心。

工厂方法模式：

优点：

1、实现了对象的创建和使用分离。

2、系统的可扩展性提高，不用修改接口和原类。

3、不需要记住具体的类名，甚至连具体的参数都不用去记住。

缺点：

1、增加了系统中类的个数。复杂度和理解难度增加

2、增加了系统的抽象性

#include<iostream>
using namespace std;
class Abfruit
{
public:
	virtual void showname() = 0;
};
class Apple : public  Abfruit
{
public:
	virtual void showname()
	{
		cout << "这是苹果" << endl;
	}
};
class Banner : public  Abfruit
{
public:
	virtual void showname()
	{
		cout << "这是香蕉" << endl;
	}
};
class AbFactort
{
public:
	virtual Abfruit* setFruir() = 0;
};
class AppleFactory : public AbFactort
{
public:
	virtual Abfruit* setFruir()
	{
		return new Apple;
	}
};
class BannerFactory : public AbFactort
{
public:
	virtual Abfruit* setFruir()
	{
		return new Banner;
	}
};
int main()
{
	AbFactort* abfactory = NULL;
	Abfruit* abfruit = NULL;
	abfactory = new AppleFactory;
	abfruit = abfactory->setFruir();
	abfruit->showname();
	delete abfruit;
	delete abfactory;
	abfactory = new BannerFactory;
	abfruit = abfactory->setFruir();
	abfruit->showname();
	delete abfruit;
	delete abfactory;
}

适用场景：

1、客户端不知道它所需要的对象的类。

2、抽象工厂类通过其子类来指定创建哪个对象。

观察者模式：

建立一种对象与对象之间的依赖关系。

在观察者模式中，发生改变的对象称之为观察对象，而被通知的对象称为观察者。

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

class AbHero {
public:
	virtual void update() = 0;
};

class HeroA : public AbHero {
public:
	HeroA()
	{
		cout << " A 正在攻击BOSS" << endl;
	}
	virtual void update()
	{
		cout << " A 停止攻击 待机状态" << endl;
	}
};

class HeroB : public AbHero {
public:
	HeroB()
	{
		cout << " B 正在攻击BOSS" << endl;
	}
	virtual void update()
	{
		cout << " B 停止攻击 待机状态" << endl;
	}
};

class HeroC : public AbHero {
public:
	HeroC()
	{
		cout << " C 正在攻击BOSS" << endl;
	}
	virtual void update()
	{
		cout << " C 停止攻击 待机状态" << endl;
	}
};

class AbBoss {
public:
	virtual void addHero(AbHero* hero) = 0;
	virtual void deleteHero(AbHero* hero) = 0;
	virtual void notify() = 0;
};

class BossA : public AbBoss
{
public:
	virtual void addHero(AbHero* hero)
	{
		Hero_list.push_back(hero);
	}
	virtual void deleteHero(AbHero* hero) {
		Hero_list.remove(hero);
	
	}
	virtual void notify() {
		for (auto i = Hero_list.begin(); i != Hero_list.end(); i++)
		{
			(*i)->update();
		}
	}
public:
	list<AbHero*> Hero_list;
};

void test01()
{
	AbHero* A = new HeroA;
	AbHero* B = new HeroB;
	AbHero* C = new HeroC;
	BossA BA;
	BA.addHero(A);
	BA.addHero(B);
	BA.addHero(C);
	cout << " 英雄 C 阵亡  " << endl;
	BA.deleteHero(C);
	cout << " BOSS 阵亡 " << endl;
	BA.notify();

}

int main()
{
	test01();
}