C++设计模式

什么是设计模式？
设计模式就是描述不断重复发生的问题，以及解决该问题的核心方法，并将其总结成让人易于理解的可重用代码，以此来减少我们的重复劳动。

设计模式的分类：

1.根据目的可分为：创建型、结构型、行为型

2.根据范围可分为：类模式、对象模式

1.简单工厂模式

定义一个工厂类，可以根据参数的不同返回不同的类实例（具有共同的父类），简单工厂模式也称为静态工厂方法模式，属于创建型模式。

其要点在于，只需要传入正确的参数，就可以获取所需要的对象，无需知道其具体实现细节。

简单工厂模式包含如下角色

1. Factory(工厂类)：
是核心，负责实现创建所有产品实例的内部逻辑，可以直接被外界调用，实现所需要的产品。

2. Product(抽象产品类)：
是工厂类所创建的所有对象的父类，封装了各种产品对象的公有方法。

3. ConcreteProduct(具体产品类)：
是最终的创建目标，继承了抽象产品角色，需要实现其抽象方法。

简单示例

#include<iostream>
#include<stdexcept>
#include<cstddef>
#include<string>
#include<map>
using namespace std;
class BadShapeCreation :public logic_error
{
public:
	BadShapeCreation(string type)
		:logic_error("Cannot create type" + type) {}
};

class Shape//抽象产品类
{
public:
	virtual void draw() = 0;//纯虚函数
	virtual void erase() = 0;
	virtual ~Shape(){}
	static Shape* factory(const string& type);
};

class Circle :public Shape//具体产品类1
{
	Circle() {}//私有
	friend class Shape;//友元(访问私有)
public:
	void draw()
	{
		cout << "Draw a Circle" << endl;
	}
	void erase()
	{
		cout << "Erase a Circle" << endl;
	}
	~Circle()
	{
		cout << "~Circle" << endl;
	}
};
class Square :public Shape
{
	Square() {}//私有
	friend class Shape;//友元(访问私有)
public:
	void draw()
	{
		cout << "Draw a Square" << endl;
	}
	void erase()
	{
		cout << "Erase a Square" << endl;
	}
	~Square()
	{
		cout << "~Square" << endl;
	}
};
Shape* Shape::factory(const string& type)throw(BadShapeCreation)
{
	if (type == "Circle")return new Circle;
	if (type == "Square")return new Square;
	throw BadShapeCreation(type);
}

class ShapeFactory
{
	std::map<string, Shape*>shapes;
public:
	ShapeFactory(string str[], int n)
	{
		for (int i = 0; i < n; ++i)
		{
			shapes.insert(std::map<string, Shape*>::value_type(str[i], Shape::factory(str[i])));
		}
	}
	~ShapeFactory()
	{
		for (auto&x:shapes)
		{
		}
	}
	Shape* GetShape(const string str)
	{
		return shapes[str];
	}
};

int main()
{
	string sname;
	string str[] = { "Circle","Square" };
	int n = sizeof(str) / sizeof(str[0]);
	ShapeFactory sfact(str, n);
	Shape* sp = nullptr;
	cin >> sname;
	sp = sfact.GetShape(sname);
	sp->draw();
	return 0;
}

2.工厂方法模式

3.单例模式

3.1 饿汉单例模式

3.2 懒汉单例模式

3.3 模板加继承

4.结构型模式

4.1 代理模式

4.2 适配器模式

简单示例：

#include<iostream>

using namespace std;

class Target//女朋友
{
public:
	virtual void request()
	{
		cout << "Trget::request" << endl;
	}
};

class Adaptee//男朋友
{
public:
	virtual void specificRequest()
	{
		cout << "SpecificRequest" << endl;
	}
};
/*
class Adapter :public Target//适配器
{
private:
	Adaptee* adaptee;
public:
	Adapter(){
		adaptee = new Adaptee();
	}
	virtual void request() {
		adaptee->specificRequest();
	}

};*/
class Adapter :public Target, private Adaptee//继承者模式
{
public:
	virtual void request() {
		Adaptee::specificRequest();
	}
};

int main()
{
	Target* ap = new Adapter();
	ap->request();
	return 0;
}

加入模板：

#include<iostream>

using namespace std;

class Target//女朋友
{
public:
	virtual void request()
	{
		cout << "Trget::request" << endl;
	}
};
class Adaptee_A//C男朋友
{
public:
	virtual void specificRequest() { cout << "SpecificRequest_A" << endl; }
};

class Adaptee_B//C男朋友
{
public:
	virtual void specificRequest() { cout << "SpecificRequest_B" << endl; }
};

class Adaptee_C//C男朋友
{
public:
	virtual void specificRequest() { cout << "SpecificRequest_C" << endl; }
};

template<class Type>
class Adapter :public Target
{
	Type* ap;
public:
	Adapter() :ap(new Type()) {}
	virtual void request() {
		ap->specificRequest();
	}
};
int main()
{
	Target* ap = new Adapter<Adaptee_A>();
	Target* bp = new Adapter<Adaptee_B>();
	Target* cp = new Adapter<Adaptee_C>();
	ap->request();
	bp->request();
	cp->request();
	return 0;
}

5. 行为型模式

关注系统中对象之间的相互交互，研究运行时对象之间的相互通信和协作，明确对象职责。

5.1 观察者模式

模式动机：
建立一套低耦合的消息触发机制

模式定义：
定义对象之间的一种一对多依赖关系，使得每当一个对象状态发生改变时，其相关依赖对象皆得到通知并被自动更新。

模式角色：
●Subject (目标) :
目标又称为主题，它是指被观察的对象。在目标中定义了一个观察者集合, -个观察
目标可以接受任意数量的观察者来观察，它提供一系列方法来增加和删除观察者对象， 同时它定义了通知方法
notify()。目标类可以是接口，也可以是抽象类或具体类。

●ConcreteSubjec t (具体目标) :
具体目标是目标类的子类,通常它包含有经常发生改变的数据，当它的
状态发生改变时，向它的各个观察者发出通知;同时它还实现了在目标类中定义的抽象业务逻辑方法(如果有的
话)。如果无须扩展目标类，则具体目标类可以省略。

●Observer (观察者) :
观察者将对观察目标的改变做出反应，观察者-般定义为接口，该接口声明了更新
数据的方法update(),因此又称为抽象观察者。

●ConcreteObserver (具体观察者) :
在具体观察者中维护一个指向具体目标对象的引用，它存储具体观察者的有关状态，这些状态需要和具体目标的状态保持一致; 它实现了在抽象观察者Observer中定义的update()方法。通常在实现时，可以调用具体目标类的attach()方法将自己添加到目标类的集合中或通过detach()方法将自己从目标类的集合中删除。

5.2迭代器模式

图论