单例模式

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

三要素：

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