C++设计模式_工厂模式

工厂模式是将带有继承于基类的子类的创建过程交给一个工厂来创建，通过赋予不同的创建标识来创建不同的子类的模式。

C++有三种工厂模式：简单工厂模式、工厂模式和抽象工厂模式

简单工厂模式：现在有一个工厂要生产几种产品，这个简单工厂自己可以判断生产哪一种产品

代码如下：

#include <iostream>
#include <string>
#include <vld.h>
using namespace std;

class Product
{
public:
	Product(string name):_name(name){}
	virtual void Show() = 0;
	virtual ~Product(){}
protected:
	string _name;
};

class Product_A:public Product
{
public:
	Product_A(string name):Product(name){}
	virtual void Show()
	{
		cout << "Product_A::name:" << _name << endl;
	}
};

class Product_B:public Product
{
public:
	Product_B(string name):Product(name){}
	virtual void Show()
	{
		cout << "Product_B::name:" << _name << endl;
	}
};

class Factory
{
public:
	Factory(){}
	Product* CreateProduct(int flag)
	{
		switch (flag)
		{
		case 1:
			return new Product_A("A");
			break;
		case 2:
			return new Product_B("B");
			break;
		default:
			break;
		}
	}
};

int main()
{
	Factory f;
	Product* p1 = f.CreateProduct(1);
	p1->Show();
	Product* p2 = f.CreateProduct(2);
	p2->Show();

	delete p1;
	delete p2;

	return 0;
}

工厂模式：不只有如何生产一个工厂，总工厂只负责指挥，子工厂决定

代码如下：

#include <iostream>
#include <string>
#include <vld.h>
using namespace std;

class Product
{
public:
	Product(string name):_name(name){}
	virtual void Show() = 0;
	virtual ~Product(){}
protected:
	string _name;
};

class Product_A:public Product
{
public:
	Product_A(string name):Product(name){}
	virtual void Show()
	{
		cout << "Product_A::name:" << _name << endl;
	}
};

class Product_B:public Product
{
public:
	Product_B(string name):Product(name){}
	virtual void Show()
	{
		cout << "Product_B::name:" << _name << endl;
	}
};

class Factory
{
public:
	virtual Product* CreateProduct() = 0;
};

class Factory_A:public Factory
{
public:
	Product* CreateProduct()
	{
		return new Product_A("A");
	}
};

class Factory_B:public Factory
{
public:
	Product* CreateProduct()
	{
		return new Product_B("B");
	}
};

抽象工厂模式：

代码如下：

#include <iostream>
#include <string>
#include <vld.h>
using namespace std;

class Product_A
{
public:
	Product_A(string name):_name(name){}
	~Product_A(){}
	virtual void Operator() = 0;
protected:
	string _name;
};
class Product_A1:public Product_A
{
public:
	Product_A1(string name):Product_A(name){}
	void Operator()
	{
		cout << "Product_A1::Operator()" << endl;
	}
};

class Product_A2:public Product_A
{
public:
	Product_A2(string name):Product_A(name){}
	void Operator()
	{
		cout << "Product_A2::Operator()" << endl;
	}
};

class Product_B
{
public:
	Product_B(string name):_name(name){}
	~Product_B(){}
	virtual void Operator() = 0;
protected:
	string _name;
};
class Product_B1:public Product_B
{
public:
	Product_B1(string name):Product_B(name){}
	void Operator()
	{
		cout << "Product_B1::Operator()" << endl;
	}
};

class Product_B2:public Product_B
{
public:
	Product_B2(string name):Product_B(name){}
	void Operator()
	{
		cout << "Product_B2::Operator()" << endl;
	}
};

class Factory
{
public:
	virtual Product_A* CreateProductA() = 0;
	virtual Product_B* CreateProductB() = 0;
};

class Factory_1:public Factory
{
public:
	Product_A* CreateProductA()
	{
		return new Product_A1("A1");
	}
	Product_B* CreateProductB()
	{
		return new Product_B1("B1");
	}
};

class Factory_2:public Factory
{
public:
	Product_A* CreateProductA()
	{
		return new Product_A2("A2");
	}
	Product_B* CreateProductB()
	{
		return new Product_B2("B2");
	}
};

int main()
{
	Factory_2 f2;
	Product_A* p = f2.CreateProductA();
	p->Operator();

	delete p;

	return 0;
}