设计模式

单例模式

主要是为了解决一个全局使用的类的频繁创建和销毁的问题。

三要素：

1.某个类只有一个实例；

2.该类自行创建这个实例；

3.该类自行向整个系统提供这个实例；

工厂模式

主要是为了解决创建对象的接口选择问题，该模式下定义一个创建对象的接口，将创建对象的过程延迟到子类去执行。

简单工厂模式

仅仅是对不同类对象进行简单的封装

看代码

//手机基类
class CPhone
{
public://make方面用于打印信息
	virtual void make() = 0;//虚函数等于0，代表虚基类，不能实例化
};

class CMiPhone:public CPhone//小米手机继承于手机基类
{
public:
	CMiPhone()
	{
		this->make();
	}
	virtual void make()
	{
		cout << "MiPhone" << endl;
	}
};

class CIPhone :public CPhone//苹果手机继承于手机基类
{
public:
	CIPhone()
	{
		this->make();
	}
	virtual void make()
	{
		cout << "IPhone" << endl;
	}

};

class CPhoneFactor //手机制作工厂
{
public:
	CPhone* makePhone(string strPhoneType) //根据手机类型创建具体的手机
	{
    //这里其实可以用map容器绑定函数来减少if——else
		if ("IPhone" == strPhoneType)
		{
			return new CIPhone();
		}
		else if ("MIPhone" == strPhoneType)
		{
			return new CMiPhone();
		}
		return nullptr;
	}
};

int main()
{
	CPhoneFactor *pFactor = new CPhoneFactor();
    //因为返回的是手机基类类型，所有要强制转换类型
	CMiPhone *pMIPhone = static_cast<CMiPhone*>(pFactor->makePhone("MIPhone"));//输出MIPhone
	CIPhone *pIPhone = static_cast<CIPhone*>(pFactor->makePhone("IPhone"));//输出IPhone
	system("pause");
	return 0;
}

上面我们可以发现，我们创建对象是通过工厂类去创建的，每添加新的手机品牌都需要添加一种手机类，工厂类这边添加一次判断。

工厂方法模式

定义了一个工厂基类，定义产品的生产接口，但不负责具体的产品，将生产任务交给派生类工厂，这样就不用指定生产的类型了。

//原有的CPhone，CMIPone，CIPone类不变，创建工厂基类，派生各种手机制作工厂


class CFactorBase//工厂基类
{
public:
	virtual CPhone* makePhone() = 0;
};

class CMiPhoneFactor:public CFactorBase//小米工厂
{
public:
	virtual CMiPhone* makePhone()
	{
		return new CMiPhone();
	}
};

class CIPhoneFactor :public CFactorBase//苹果工厂
{
public:
	virtual CIPhone* makePhone()
	{
		return new CIPhone();
	}
};


int main()
{
//创建出苹果和小米工厂
	CFactorBase *pMIPhoneFactor = new CMiPhoneFactor();
	CFactorBase *pIPhoneFactor = new CIPhoneFactor();
    //通过各自工厂生成各自产品
	CMiPhone *pMIPhone = static_cast<CMiPhone*>(pMIPhoneFactor->makePhone());
	CIPhone *pIPhone = static_cast<CIPhone*>(pIPhoneFactor->makePhone());
	system("pause");
	return 0;
}

抽象工厂模式

解决了工厂方法模式提供了新的类型的产品创建时代码的重复问题如：现在要这些公司要求生产PC，那我们就要完全重新写一遍类似的代码。

class CPhone //手机基类
{
public:
	virtual void make() = 0;
};

class CMiPhone:public CPhone//小米手机
{
public:
	CMiPhone()
	{
		this->make();
	}
	virtual void make()
	{
		cout << "MiPhone" << endl;
	}
};
class CIPhone :public CPhone//苹果手机
{
public:
	CIPhone()
	{
		this->make();
	}
	virtual void make()
	{
		cout << "IPhone" << endl;
	}

};
class CPC//电脑基类
{
public:
	virtual void make() = 0;
};

class CMiPC :public CPC//小米电脑
{
public:
	CMiPC()
	{
		this->make();
	}
	virtual void make()
	{
		cout << "MiPC" << endl;
	}
};
class CMac :public CPC//苹果电脑
{
public:
	CMac()
	{
		this->make();
	}
	virtual void make()
	{
		cout << "MAC" << endl;
	}

};
class CFactorBase//工厂基类
{
public:
	virtual CPhone* makePhone() = 0;//生产手机
	virtual CPC* makePC() = 0;//生产电脑
};

class CMiFactor:public CFactorBase//小米工厂
{
public:
	virtual CMiPhone* makePhone()
	{
		return new CMiPhone();
	}
	virtual CMiPC* makePC()
	{
		return new CMiPC();
	}

};

class CAppleFactor :public CFactorBase//苹果工厂
{
public:
	virtual CIPhone* makePhone()
	{
		return new CIPhone();
	}
	virtual CMac* makePC()
	{
		return new CMac();
	}
};

int main()
{
	CFactorBase *pMIFactor = new CMiFactor();
	CFactorBase *pAppleFactor = new CAppleFactor();
	CMiPhone *pMIPhone = static_cast<CMiPhone*>(pMIFactor->makePhone());
	CIPhone *pIPhone = static_cast<CIPhone*>(pAppleFactor->makePhone());
	CMiPC *pMiPC = static_cast<CMiPC*>(pMIPhoneFactor->makePC());
	CMac *pMac = static_cast<CMac*>(pIPhoneFactor->makePC());
	system("pause");
	return 0;
}

这个时候，我们添加一类新产品的时候，只需要增加一个创建那类产品的接口就可以，没必要再重复一遍工厂方法模式的代码了。

文章借鉴于：https://www.cnblogs.com/yssjun/p/11102162.html