C++设计模式（二）单例模式、代理模式、外观模式、模板方法模式

C++设计模式之单例模式
有某些场景需要保证类只能有一个对象，那如何实现单例模式？

大概需要如下三个步骤
1、私有化构造函数
2、private& static 静态数据： 指向对象的指针
3、提供public访问权限的方法返回指向唯一对象的指针 （该方法一定是static方法，因为构造函数是private私有的）

class SingleInstance {
public:
	//提供静态接口
	static SingleInstance* getInstance()
	{
		if(instance == NULL)
			instance = new SingleInstance;
		return instance;
	}
private:
	SingleInstance()
	{
		cout << "私有构造函数被调用" << endl;
	}
private:
	static SingleInstance* instance;
};

//static静态成员初始化
SingleInstance* SingleInstance::instance = NULL;
int main()
{
	SingleInstance* singleInstance = SingleInstance::getInstance();
}

C++设计模式之代理模式

代理模式：为其他对象提供一种代理以 控制对这个对象的访问
适用场景:一个对象不适合或者不能直接引用另一个对象， 而代理对象可以在客户端和目标对象之间起到中介的作用。

//抽象类
class AbstractInterface {
public:
	virtual void run() = 0;
};

//普通对象
class MySystem:public AbstractInterface {
public:
	virtual void run()
	{
		cout << "系统启动" << endl;
	}
};

//代理类就等于对象
class ProxySystem : public AbstractInterface
{
public:
	ProxySystem(string name, string password) :userName(name), userPassword(password) 
	{
		pSystem = new MySystem;
	}

	virtual void run()
	{
		if (checkPermission())
		{
			cout << "用户名和密码验证通过!!!" << endl;
			if (pSystem != NULL)
				pSystem->run();
		}
		else {
			cout << "用户名和密码验证不通过!!!" << endl;
		}
	}

private:
    //验证用户名和密码
	bool checkPermission()
	{
		if (this->userName == "admin" && this->userPassword == "admin")
		{
			return true;
		}
		else {
			return false;
		}
	}
private:
	MySystem* pSystem;
	string userName;
	string userPassword;
};

int main()
{
	ProxySystem* proxySystem = new ProxySystem("admin", "admin");
	proxySystem->run();
}

C++设计模式之外观模式

外观模式就是将复杂的子系统抽象到同一个的接口进行管理。外观只需要通过此接口与子系统进行交互，而不需要和复杂的子系统进行交互。

例子1

//子系统1
class System1 {
public:
	void run()
	{
		cout << "子系统1运行了" << endl;
	}
};

//子系统2
class System2 {
public:
	void run()
	{
		cout << "子系统2运行了" << endl;
	}
};

//子系统3
class System3 {
public:
	void run()
	{
		cout << "子系统3运行了" << endl;
	}
};

class Faced {
public:
	Faced()
	{
		pSystem1 = new System1;
		pSystem2 = new System2;
		pSystem3 = new System3;
	}

	void runSystem()
	{
		pSystem1->run();
		pSystem2->run();
		pSystem3->run();
	}
private:
	System1* pSystem1;
	System2* pSystem2;
	System3* pSystem3;
};

int main()
{
	Faced faced;
	faced.runSystem();
}

例子2：
实现KTV模式：打开tv 打开music
实现静音模式: 打开tv 关闭music

class Tv {
public:
	void on()
	{
		cout << "电视打开" << endl;
	}

	void off()
	{
		cout << "电视关闭" << endl;
	}
};

class Music {
public:
	void on()
	{
		cout << "音乐打开" << endl;
	}

	void off()
	{
		cout << "音乐关闭" << endl;
	}
};
//ktv模式
class KtvMode {
public:
	KtvMode()
	{
		tv = new Tv;
		music = new Music;
	}
	void run()
	{
		tv->on();
		music->on();
	}
	~KtvMode()
	{
		if (tv != NULL)
			delete tv;
		if (music != NULL)
			delete music;
	}
private:
	Tv* tv;
	Music* music;
};

//静音模式
class NoSoundMode {
public:
	NoSoundMode()
	{
		tv = new Tv;
		music = new Music;
	}
	void run()
	{
		tv->on();
		music->off();
	}
	~NoSoundMode()
	{
		if (tv != NULL)
			delete tv;
		if (music != NULL)
			delete music;
	}
private:
	Tv* tv;
	Music* music;
};
int main()
{
	KtvMode* ktv = new KtvMode;
	ktv->run();
	delete ktv;

	NoSoundMode* mode = new NoSoundMode;
	mode->run();
	delete mode;
}

C++设计模式之模板方法模式

定义：定义一个 *** 作中算法的框架，而将一些步骤延迟到子类中。模板方法模式使得子类可以不改变一个算法的结构儿科重定义该算法的某些特定步骤。

场景：冲咖啡的过程 1、烧水 2、冲咖啡 3、倒入杯中 4、加料
同样冲茶叶过程 1、烧水 2、冲茶叶3、倒入杯中 4、加料

class DrinkTemplate {
public:
	virtual void boilWater() = 0;
	virtual void brew() = 0;
	virtual void pourInCup() = 0;
	virtual void addSomething() = 0;
	//模板方法
	void make()
	{
		this->boilWater();
		this->brew();
		this->pourInCup();
		this->addSomething();
	}
};

class Tea : public DrinkTemplate {
public:
	virtual void boilWater()
	{
		cout << "烧水" << endl;
	}
	virtual void brew()
	{
		cout << "冲泡茶叶" << endl;
	}
	virtual void pourInCup() {
		cout << "倒入杯中" << endl;
	}
	virtual void addSomething()
	{
		cout << "加入物料" << endl;
	}
};

class Coffee : public DrinkTemplate {
public:
	virtual void boilWater()
	{
		cout << "烧水" << endl;
	}
	virtual void brew()
	{
		cout << "冲泡咖啡" << endl;
	}
	virtual void pourInCup() {
		cout << "倒入杯中" << endl;
	}
	virtual void addSomething()
	{
		cout << "加入物料" << endl;
	}
};

int main()
{
	DrinkTemplate* drink = new Tea;
	drink->make();
	delete drink;

	drink = new Coffee;
	drink->make();
	delete drink;
}

总结：
优点：

1. 在父类形式化地定义一个算法，而由它的子类来实现它的细节处理，在子类实现具体细节时并不会改变算法中的步骤的执行顺序。
2. 模板方式模式是一种代码复用技术，它在类库设计中尤为重要。它提取了类库中的公共行为，将公共行为放在父类中，而通过其子类来实现不同的行为，它鼓励我们恰当使用继承来实现代码复用。
3. 在模板方式模式中可以通过子类来覆盖父类的方法，不同的子类可以提供基本方法的不同实现，更换和增加新的子类很方便，符合单一职责原则和开闭原则。
4. 可实现一种方向控制结构，通过子类覆盖父类的钩子方法来决定某一特定步骤是否需要执行。