【c++】工厂模式

工厂模式的两个最重要功能：

(1)定义创建对象的接口，封装了对象的创建

(2)使得具体化类的工作延迟到子类中

1.简单工厂模式

#include<iostream>

class Product
{
public:
	Product(std::string name):mname(name)
	{}
	virtual void operation() = 0;
	virtual ~Product(){}
private:
	std::string mname;
};

class ProductA:public Product
{
public:
	ProductA(std::string name):Product(name)
	{}
	virtual void operation()
	{
		std::cout<<"A"<<std::endl;
	}
	virtual ~ProductA(){}
};

class ProductB:public Product
{
public:
	ProductB(std::string name):Product(name){}
	virtual void operation()
	{
		std::cout<<" B"<<std::endl;
	}
	virtual ~ProductB(){}
};

class Factory
{
public:
	Product* create(int flag)
	{
		switch(flag)
		{
			case 1:
				return new ProductA("PA");
				break;
			case 2:
				return new ProductB("PB");
				break;
			default:
				std::cout<<"can not product"<<std::endl;
				break;
		}
	}
};

int main()
{
	Factory *p = new Factory();
	Product *pro = p->create(1);
	pro->operation();
        delete p;
        delete pro;
	return 0;
}

此时，若是想多生产C产品，若是直接在switch语句中强制添加会破坏开放封闭性原则。此时考虑工厂方法模式，就是为每一个产品生产开一个工厂，准守了开放封闭性原则。

2.工厂方法模式

#include<iostream>

class Product
{
public:
	Product(std::string name):mname(name){}
	virtual void operation() = 0;
	virtual ~Product(){}
private:
	std::string mname;
};

class ProductA:public Product
{
public:
	ProductA(std::string name):Product(name){}
	virtual void operation()
	{
		std::cout<<"A"<<std::endl;
	}
	virtual ~ProductA(){}
};

class ProductB:public Product
{
public:
	ProductB(std::string name):Product(name){}
	virtual void operation()
	{
		std::cout<<"A"<<std::endl;
	}
	virtual ~ProductB(){}
};
class ProductC:public Product
{
public:
	ProductC(std::string name):Product(name){}
	virtual void operation()
	{
		std::cout<<"A"<<std::endl;
	}
	virtual ~ProductC(){}
};

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

class FactoryA:public Factory
{
public:
	virtual Product* create()
	{
		return new ProductA("PA");
	}
	virtual ~FactoryA(){};
};

class FactoryB:public Factory
{
public:
	virtual Product* create()
	{
		return new ProductB("PB");
	}
	virtual ~FactoryB(){};
};

class FactoryC:public Factory
{
public:
	virtual Product* create()
	{
		return new ProductC("PC");
	}
	virtual ~FactoryC(){};
};
int main()
{
	Factory *p = new FactoryA;
	Product* pro = p->create();
	pro->operation();
        delete p;
        delete pro;
	return 0;
}

 

3.抽象工厂模式

解决创建一组或相互依赖的对象

#include<iostream>


class ProductA
{
public:
	ProductA(std::string name) :mname(name){}
	virtual void operation() = 0;
	virtual ~ProductA(){}
protected:
	std::string mname;
};
class ProductB
{
public:
	ProductB(std::string name) :mname(name){}
	virtual void operation() = 0;
	virtual ~ProductB(){}
protected:
	std::string mname;
};
class ProductA1 :public ProductA
{
public:
	ProductA1(std::string name) :ProductA(name){}
	void operation()
	{
		std::cout << "A1" << std::endl;
	}
};
class ProductA2 :public ProductA
{
public:
	ProductA2(std::string name) :ProductA(name){}
	void operation()
	{
		std::cout << "A2" << std::endl;
	}
};
class ProductB1 :public ProductB
{
public:
	ProductB1(std::string name) :ProductB(name){}
	void operation()
	{
		std::cout << "B1" << std::endl;
	}
};
class ProductB2 :public ProductB
{
public:
	ProductB2(std::string name) :ProductB(name){}
	void operation()
	{
		std::cout << "B2" << std::endl;
	}
};

class AbstractFactory
{
public:
	virtual ProductA* createProductA() = 0;
	virtual ProductB* createProductB() = 0;
	virtual ~AbstractFactory(){}
};
class Factory_1 : public AbstractFactory
{
public:
	virtual ProductA* createProductA()
	{
		return new ProductA1("PA1");
	}
	virtual ProductB* createProductB()
	{
		return new ProductB1("PB1");
	}
};
class Factory_2 : public AbstractFactory
{
public:
	virtual ProductA* createProductA()
	{
		return new ProductA2("PA2");
	}
	virtual ProductB* createProductB()
	{
		return new ProductB2("PB2");
	}
};

int main()
{
	AbstractFactory *p = new Factory_1();
	ProductA* pro = p->createProductA();
	pro->operation();
	ProductB* pre = p->createProductB();
	pre->operation();
	return 0;
}