复习复习C++工厂模式

1.引言。

复习复习工厂模式。
工厂模式属于创建型模式，分为简单工厂模式、工厂方法模式、抽象工厂模式三种。

2、简单工厂模式。

2.1 概述。
特征： 一个工厂，多个产品。
表现： 产品仅有一个虚基类。通过传入参数，创建具体产品对象。
优点： 通过工厂获取此虚基类指针，通过运行时多态，子类化实现各种产品功能。
缺点： 当Factory要生产一个新的产品时，就要修改Factory类，然而这样就违背了开放封闭原则.

构建一个战舰工厂，传参数给工厂，生产的产品是航母或者潜艇

2.2 实例。

#include <iostream>
using namespace std;

enum WarshipType
{
	AircraftCarrier,
	Submarine,
};

class IWarship
{
public:
	virtual void SayHello() = 0;
};

class CAircraftCarrier :public IWarship
{
public:
	virtual void SayHello()
	{
		cout << "AircraftCarrier" << endl;
	}
};


class CSubmarine : public IWarship
{
public:
	virtual void SayHello()
	{
		cout << "Submarine" << endl;
	}
};


class CFactory
{
public:
	IWarship* CreateShip(WarshipType type)
	{
		if (type == AircraftCarrier)
		{
			return new CAircraftCarrier;
		}
		else if (type == Submarine)
		{
			return new CSubmarine;
		}
		return nullptr;
	}
public:
	static CFactory* GetInstance()
	{
		static  CFactory ins;
		return &ins;
	}
private:
	CFactory(){}
};

CFactory* GetFactory()
{
	return CFactory::GetInstance();
}


int main()
{
	GetFactory()->CreateShip(AircraftCarrier)->SayHello();
	GetFactory()->CreateShip(Submarine)->SayHello();

	cin.get();
	return 0;
}

3、工厂方法模式。

3.1 概述。
特征： 多个工厂，分别生产各自产品。
表现： 每个产品对应于一个工厂。通过类的继承来实现扩展。即从工厂基类Factory中派生出CAircraftCarrierFactory类专门用来生产CAircraftCarrier产品；
派生出CSubmarineFactory类从来生产产品CSubmarine。
这样子如果要生产新的产品时，只需要派生出新的工厂子类就行了。
优点： 当增加一个新产品时，同时增加一个新工厂。增加新工厂属于扩展，不会修改以前工厂类和产品类的任何代码。可以看做多个独立的简单工厂模式构成了工厂方法模式。
缺点： 思考：对于CAircraftCarrierFactory类，我们可能要对生产一系列AircraftCarrier，比如常规动力的AircraftCarrier和核动力的AircraftCarrier。如果还是用工厂方法模式就太繁琐了，所以引入了抽象工厂模式；

3.2 实例。

#include <iostream>
using namespace std;

class IWarship
{
public:
	virtual void SayHello() = 0;
};

class CAircraftCarrier :public IWarship
{
public:
	virtual void SayHello()
	{
		cout << "AircraftCrarrier" << endl;
	}
};

class CSubmarine : public IWarship
{
public:
	virtual void SayHello()
	{
		cout << "Submarine" << endl;
	}
};


class IFactory
{
public:
	virtual IWarship* CreateWarship() = 0;
};

class CAircraftCarrierFactory : public IFactory
{
public:
	virtual IWarship* CreateWarship()
	{
		return new CAircraftCarrier;
	}
public:
	static CAircraftCarrierFactory* GetInstance()
	{
		static CAircraftCarrierFactory ins;
		return &ins;
	}
private:
	CAircraftCarrierFactory(){}
};

CAircraftCarrierFactory* GetAircraftCarrierFactory()
{
	return CAircraftCarrierFactory::GetInstance();
}

class CSubmarineFactory :public IFactory
{
public:
	virtual IWarship* CreateWarship()
	{
		return new CSubmarine;
	}
public:
	static CSubmarineFactory* GetInstance()
	{
		static CSubmarineFactory ins;
		return &ins;
	}
private:
	CSubmarineFactory(){}
};
CSubmarineFactory* GetSubmarineFactory()
{
	return CSubmarineFactory::GetInstance();
}


int main()
{

	GetAircraftCarrierFactory()->CreateWarship()->SayHello();
	GetSubmarineFactory()->CreateWarship()->SayHello();
	
	cin.get();
	return 0;
}

4、抽象工厂模式。

4.1 概述。
特征： 多个工厂，多种产品，并且每种产品包含多个型号。
表现： 工厂和产品都是通过虚基类的方式构建。每个工厂类可以生产同一个产品的多个型号。父类Factory只指定要生产常规动力类和核动力类，而不需要指定CAircraftCarrierFactory、CSubmarineFactory类等等。
优点： 提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
缺点： 逻辑比较复杂。

#include <iostream>
using namespace std;

class IWarshipCommonPower
{
public:
	virtual void SayHello() = 0;
};

class CAircraftCarrierCommonPower :public IWarshipCommonPower
{
public:
	virtual void SayHello()
	{
		cout << "common power aircraftCarrier" << endl;
	}
};
class CSubmarineCommonPower : public IWarshipCommonPower
{
public:
	virtual void SayHello()
	{
		cout << "common power submarine" << endl;
	}
};


class IWarShipNuclear
{
public:
	virtual void SayHello() = 0;
};
class CAircraftCarrierNuclear : public IWarShipNuclear
{
public:
	virtual void SayHello()
	{
		cout << "nuclear power AircraftCarrier" << endl;
	}
};
class CSubmarineNuclear :public IWarShipNuclear
{
public:
	virtual void SayHello()
	{
		cout << "nuclear power Submarine" << endl;
	}
};



//工厂接口
class IFactory
{
	//只指定要生产常规动力类或者核动力类，而不需要指定要生产AircraftCarrier类还是SubMarine类
public:
	virtual IWarshipCommonPower* CreateWarShipCommonPower() = 0;
	virtual IWarShipNuclear* CreateWarShipNuclear() = 0;
};

class CAircraftCarrierFactory :public IFactory
{
public:
	virtual IWarshipCommonPower* CreateWarShipCommonPower()
	{
		return new CAircraftCarrierCommonPower;
	}
	virtual IWarShipNuclear* CreateWarShipNuclear()
	{
		return new CAircraftCarrierNuclear;
	}

public:
	static CAircraftCarrierFactory *GetInstance()
	{
		static CAircraftCarrierFactory ins;
		return &ins;
	}
private:
	CAircraftCarrierFactory(){}
};
CAircraftCarrierFactory* GetAircraftCarrierFactory()
{
	return CAircraftCarrierFactory::GetInstance();
}


class CSubmarineFactory :public IFactory
{
public:
	virtual IWarshipCommonPower* CreateWarShipCommonPower()
	{
		return new CSubmarineCommonPower;
	}
	virtual IWarShipNuclear* CreateWarShipNuclear()
	{
		return new CSubmarineNuclear;
	}
public:
	static CSubmarineFactory* GetInstance()
	{
		static CSubmarineFactory ins;
		return &ins;
	}
private:
	CSubmarineFactory(){}
};
CSubmarineFactory* GetSubmarineFactory()
{
	return CSubmarineFactory::GetInstance();
}


int main()
{
	GetAircraftCarrierFactory()->CreateWarShipCommonPower()->SayHello();
	GetAircraftCarrierFactory()->CreateWarShipNuclear()->SayHello();

	GetSubmarineFactory()->CreateWarShipCommonPower()->SayHello();
	GetSubmarineFactory()->CreateWarShipNuclear()->SayHello();

	cin.get();
	return 0;
}

入门萌新，浅知拙见，若有斧正，不胜感激。^ - ^

参考文章：https://blog.csdn.net/jigetage/article/details/79605624
参考文章：https://blog.csdn.net/wuzhekai1985/article/details/6660462