工厂模式总结

简单工厂模式

#include <iostream>
using namespace std;

/****************************************
功能设计：类定义
****************************************/
typedef enum {
	PRODUCT_TYPE_HAIR,
	PRODUCT_TYPE_HISENCE
} PRODUCT_TYPE;

// 抽象产品类
class TV {
public:
	virtual void show() = 0;
	virtual ~TV();
};

// 具体产品类：HairTV
class HairTV : public TV {
public:
	void show() override;
};

// 具体产品类：HisenceTV
class HisenceTV : public TV {
public:
	void show() override;
};

// 简单工厂
class TVFactory {
public:
	TV* CreateTV(PRODUCT_TYPE type);
};

/****************************************
功能设计：类函数成员实现
****************************************/
TV::~TV()
{
}

void HairTV::show()
{
	cout << "I am HairTV" << endl;
}

void HisenceTV::show()
{
	cout << "I am HisenceTV" << endl;
}

TV* TVFactory::CreateTV(PRODUCT_TYPE type)
{
	switch (type)
	{
	case PRODUCT_TYPE_HAIR:
		return new HairTV();
	case PRODUCT_TYPE_HISENCE:
		return new HisenceTV();
	default:
		return NULL;
	}
}

/****************************************
功能设计：main调用
****************************************/
int main()
{
	// 创建工厂对象
	TVFactory* tvFactory = new TVFactory();
	// 创建HairTV产品
	TV* hairTV = tvFactory->CreateTV(PRODUCT_TYPE_HAIR);
	if (NULL == hairTV)
	{
		cout << "hairTV is NULL" << endl;
		return -1;
	}
	hairTV->show();

	// 创建HisenceTV产品
	TV* hisenceTV = tvFactory->CreateTV(PRODUCT_TYPE_HISENCE);
	if (NULL == hisenceTV)
	{
		cout << "hisenceTV is NULL" << endl;
		return -1;
	}
	hisenceTV->show();

	// 销毁
	delete tvFactory;
	tvFactory = NULL;
	delete hairTV;
	hairTV = NULL;
	delete hisenceTV;
	hisenceTV = NULL;
	system("pause");
	return 0;

}

工厂模式

#include <iostream>
using namespace std;

///****************************************
//功能设计：类定义
//****************************************/
// 抽象产品类
class TV {
public:
	virtual void show() = 0;
};

// 具体产品HairTV
class HairTV : public TV {
public:
	void show() override;
};

// 具体产品HisenceTV
class HisenseTV : public TV {
public:
	void show() override;
};

// 抽象工厂
class TVFactory {
public:
	~TVFactory();
	virtual TV* CreateTV() = 0;
};

// 具体工厂类：HairTVFactory
class HairTVFactory : public TVFactory {
public:
	TV* CreateTV() override;
};

// 具体工厂类：HisenseTVFactory
class HisenseTVFactory : public TVFactory {
public:
	TV* CreateTV() override;
};

/****************************************
功能设计：类函数成员实现
****************************************/
TVFactory::~TVFactory()
{

}

void HairTV::show()
{
	cout << "I am HairTV" << endl;
}

void HisenseTV::show()
{
	cout << "I am HisenceTV" << endl;
}

TV* HairTVFactory::CreateTV()
{
	return new HairTV();
}

TV* HisenseTVFactory::CreateTV()
{
	return new HisenseTV();
}

/****************************************
功能设计：main调用
****************************************/
int main()
{
	// 定义具体工厂:HairTVFactory
	TVFactory *hairTVFactory = new HairTVFactory();
	// 创建具体产品:hairTV
	TV* hairTV = hairTVFactory->CreateTV();
	hairTV->show();

	// 定义具体工厂:HisenseTVFactory
	TVFactory *hisenseTVFactory = new HisenseTVFactory();
	// 创建具体产品:hairTV
	TV* hisenseTV = hisenseTVFactory->CreateTV();
	hisenseTV->show();

	system("pause");
	return 0;
}

抽象工厂模式

/****************************************
功能设计：抽象工厂模式
抽象工厂模式是工厂模式的泛化版，工厂模式是一种特殊的抽象工厂模式。
在工厂模式中，每个具体工厂只能生产一种具体产品。如海尔电视机厂只能生产海尔电视机
而抽象工厂中，一个具体的工厂可以生产多个具体产品
****************************************/
#include <iostream>
using namespace std;

/****************************************
功能设计：类定义
****************************************/
// 抽象产品TV
class TV {
public:
	virtual void show() = 0;
};

// 抽象产品AirCondition
class AirCondition {
public:
	virtual void show() = 0;
};

// 具体产品HairTV
class HairTV : public TV {
public:
	void show() override;
};

// 具体产品HisenseTV
class HisenseTV : public TV {
public:
	void show() override;
};

// 具体产品HairAirCondition
class HairAirCondition : public AirCondition {
public:
	void show() override;
};

// 具体产品HisenseAirCondition
class HisenseAirCondition : public AirCondition {
public:
	void show() override;
};

// 抽象工厂Factory
class Factory {
public:
	virtual TV* CreateTV() = 0;
	virtual AirCondition* CreateAirCondition() = 0;
};

// 具体工厂HairFactory
class HairFactory : public Factory {
public:
	TV* CreateTV() override;
	AirCondition* CreateAirCondition() override;
};

// 具体工厂HisenseFactory
class HisenseFactory : public Factory {
public:
	TV* CreateTV() override;
	AirCondition* CreateAirCondition() override;
};

/****************************************
功能设计：类成员函数实现
****************************************/
void HairTV::show()
{
	cout << "I am HairTV" << endl;
}

void HisenseTV::show()
{
	cout << "I am HisenseTV" << endl;
}

void HairAirCondition::show()
{
	cout << "I am HairAirCondition" << endl;
}

void HisenseAirCondition::show()
{
	cout << "I am HisenseAirCondition" << endl;
}

TV* HairFactory::CreateTV()
{
	return new HairTV();
}

AirCondition* HairFactory::CreateAirCondition()
{
	return new HairAirCondition();
}

TV* HisenseFactory::CreateTV()
{
	return new HisenseTV();
}

AirCondition* HisenseFactory::CreateAirCondition()
{
	return new HisenseAirCondition();
}

/****************************************
功能设计：main函数
****************************************/
int main()
{
	// 获取具体工厂HairFactory
	Factory* hairFactory = new HairFactory();
	TV* hairTV = hairFactory->CreateTV();
	hairTV->show();
	AirCondition* hairAirCondition = hairFactory->CreateAirCondition();
	hairAirCondition->show();

	// 获取具体工厂HisenseFactory
	Factory* hisenseFactory = new HisenseFactory();
	TV* hisenseTV = hisenseFactory->CreateTV();
	hisenseTV->show();
	AirCondition* hisenseAirCondition = hisenseFactory->CreateAirCondition();
	hisenseAirCondition->show();

	system("pause");
	return 0;
}