C++day12设计模式部分（上）

1.设计模式的基本原则

1.开放封闭原则：类的改动是通过增加代码进行的，而不是修改源代码

2.依赖倒置原则：依赖于抽象（接口），不要依赖具体的实现（类），也就是针对接口编程

3.迪米特法则：一个软件实体应当尽可能少地与其他实体发生互相作用

4.接口隔离原则：不应该强迫客户的程序依赖他们不需要的接口方法。

5.里式替换原则：任何抽象类出现的地方都可以用他的实现类进行替换。

6.合成复用原则：如果使用继承，会导致父类的任何变换都可能影响到子类的行为。如果使用对象组合，就降低了这种依赖关系

因为这部分我自己学的也不是太懂，只能依葫芦画瓢的说出几种常用的设计模式。但至少在面试官面前能说上一句俩句话

2.常见常用的设计模式

2.1单例模式

#include <iostream>

using namespace std;

// 懒汉式单单例
class UserManager
{
private:
	UserManager()
	{
		cout << "构造函数被调用" << endl;
	}

public:
	static UserManager* GetInstance()
	{
		if (m_instance == NULL)
			m_instance = new UserManager;

		handle_count++;
		return m_instance;
	}

	static void Release()
	{
		if (handle_count > 0)
			handle_count--;

		if (m_instance != NULL && handle_count == 0)
		{
			delete m_instance;
			m_instance == NULL;
		}
	}

private:
	static UserManager* m_instance;   // 对象指针，  句柄
	static int handle_count;          // 引用计数
};

UserManager* UserManager::m_instance = NULL; 
int UserManager::handle_count  = 0;

// 饿汉式单例
class UserManager1
{
private:
	UserManager1()
	{
		cout << "构造函数被调用" << endl;
	}

public:
	static UserManager1* GetInstance()
	{
		handle_count++;
		return m_instance;
	}

	static void Release()
	{
		if (handle_count > 0)
			handle_count--;

		if (m_instance != NULL && handle_count == 0)
		{
			delete m_instance;
			m_instance == NULL;
		}
	}

private:
	static UserManager1* m_instance;   // 对象指针，  句柄
	static int handle_count;          // 引用计数
};

UserManager1* UserManager1::m_instance = new UserManager1; 
int UserManager1::handle_count  = 0;



int main()
{
	// 对象创建 -----> 调用构造函数  -----> 构造函数设为私有？=
	UserManager *p1 = UserManager::GetInstance();
	UserManager *p2 = UserManager::GetInstance();
	if (p1 == p2)
		cout << "两个对象相等" << endl;
	else
		cout << "两个对象不相等" << endl;

	UserManager::Release();

    return 0;
}

单例模式构造图

为什么要使用单例模式

1.在多个线程之间，比如初始化一次socket资源

2.整个程序空间使用全局变量，共享资源

3.大规模系统中，为了性能的考虑。需要节省对象的创建时间

实现单利的步骤：构造函数私有化，提供一个全局的静态方法，在类中定义一个静态指针，指向本类的变量的静态变量指针

单例模式分类1，懒汉式，2，饿汉式

2.2工厂模式（简单工厂模式）

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

// 人物的抽象类
class Hero
{
public:
	virtual void printName() = 0;
};

class YS:public Hero
{
public:
	virtual void printName()
	{
		cout << "我是 亚索" << endl;
	}
};

class MS:public Hero
{
public:
	virtual void printName()
	{
		cout << "我是 盲僧" << endl;
	}
};


// 工厂的抽象类
class AbsFactory
{
public:
	virtual Hero *createHero() = 0;
};

// 创建亚索的工厂
class YS_Factory:public AbsFactory
{
public:
	virtual Hero *createHero()
	{
		return new YS;
	}
};
// 创建盲僧的工厂
class MS_Factory:public AbsFactory
{
public:
	virtual Hero *createHero()
	{
		return new MS;
	}
};



int main()
{
	AbsFactory *pf1 = new YS_Factory;  // 生产亚索的工厂
	Hero *p1 = pf1->createHero();      // 生产一个亚索
	p1->printName();


	AbsFactory *pf2 = new MS_Factory;   // 生产盲僧的工厂
	Hero *p2 = pf2->createHero();       // 生产一个盲僧
	p2->printName();

	return 0;
}

概念

工厂方法模式同样属于类的创建型模式又被称为多态工厂模式 。工厂方法模式的意义是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。
核心工厂类不再负责产品的创建，这样核心类成为一个抽象工厂角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。

构造图

工厂方法模式与简单工厂模式在结构上的不同不是很明显。工厂方法类的核心是一个抽象工厂类，而简单工厂模式把核心放在一个具体类上。
工厂方法模式之所以有一个别名叫多态性工厂模式是因为具体工厂类都有共同的接口，或者有共同的抽象父类。
当系统扩展需要添加新的产品对象时，仅仅需要添加一个具体对象以及一个具体工厂对象，原有工厂对象不需要进行任何修改，也不需要修改客户端，很好的符合了“开放－封闭”原则。而简单工厂模式在添加新产品对象后不得不修改工厂方法，扩展性不好。工厂方法模式退化后可以演变成简单工厂模式。