};
//生产A的工厂
class FactoryA: public Factory
{
public:
Product* CreateProduct()
{
return new ProductA;
}
};
//生产B的工厂
class FactoryB: public Factory
{
public:
Product* CreateProduct()
{
return new ProductB;
}
};
int main()
{
Factory* fac = new FactoryA(); //A工厂
Product* p = fac->CreateProduct(); //生产产品
p->Show();
return 0;
}
其实你会发现，工厂方法把简单工厂的内部逻辑判断移到了客户端代码来进行，你想要加功能，本来是改工厂类的，而现在是修改客户端。
这有什么好处呢？举个例子，有三个客户原来要A产品，现在改卖B产品，在代码中体现为：
简单工厂的处理：
[cpp] Factory fac; //工厂
Product *pro1 = fac.CreateProduct(PRODUCT_A);//生产产品A
Product *pro2 = fac.CreateProduct(PRODUCT_A);//生产产品A
Product *pro3 = fac.CreateProduct(PRODUCT_A);//生产产品A
//改为B产品，这里要改三个地方
//Product *pro1 = fac.CreateProduct(PRODUCT_B);//生产产品B
//Product *pro2 = fac.CreateProduct(PRODUCT_B);//生产产品B
//Product *pro3 = fac.CreateProduct(PRODUCT_B);//生产产品B
pro1->Show();
pro2->Show();
pro3->Show();
Factory fac; //工厂
Product *pro1 = fac.CreateProduct(PRODUCT_A);//生产产品A
Product *pro2 = fac.CreateProduct(PRODUCT_A);//生产产品A
Product *pro3 = fac.CreateProduct(PRODUCT_A);//生产产品A
//改为B产品，这里要改三个地方
//Product *pro1 = fac.CreateProduct(PRODUCT_B);//生产产品B
//Product *pro2 = fac.CreateProduct(PRODUCT_B);//生产产品B
//Product *pro3 = fac.CreateProduct(PRODUCT_B);//生产产品B
pro1->Show();
pro2->Show();
pro3->Show();工厂方法的处理：
[cpp] Factory* fac = new FactoryA(); //A工厂
//改为B产品，这里只改一个地方
//Factory* fac = new FactoryB(); //B工厂
Product* pro1 = factory_A->CreateProduct(); //生产产品
Product* pro2 = factory_A->CreateProduct(); //生产产品
Product* pro3 = factory_A->CreateProduct(); //生产产品
pro1->Show();
pro2->Show();
pro3->Show();
Factory* fac = new FactoryA(); //A工厂
//改为B产品，这里只改一个地方 www.2cto.com
//Factory* fac = new FactoryB(); //B工厂
Product* pro1 = factory_A->CreateProduct(); //生产产品
Product* pro2 = factory_A->CreateProduct(); //生产产品
Product* pro3 = factory_A->CreateProduct(); //生产产品
pro1->Show();
pro2->Show();
pro3->Show();这里可以看到工厂方法的好处了吧，工厂方法模式是简单工厂模式的进一步抽象和推广，它集中封装了对象的创建，使得要更换产品时，不需要做大的改动就可以实现，降低了客户程序与产品对象的耦合。
优点：
相对于简单工厂模式来说，这样分工更加明确，当需要新产品时，就建一个新的工厂，而不是对原工厂类进行修改。这样做满足了"开放－封闭"原则，即可以扩展，不可修改。
缺点：
1. 每增加一种产品，就需要增加一个对象的工厂。在C++实现中，就是要定义一个个的工厂类。显然，相比简单工厂模式，工厂方法模式需要更多的类定义。
2. Factory 模式仅仅局限于一类类（就是说 Product 是一类，有一个共同的基类），如果我们要为不同类的类提供一个对象创建的接口，那就要用AbstractFactory了。
打个比方：
如果这家公司发展迅速，推出了很多新的产品，那么就要开设相应的新工厂，一种产品一个工厂。这对于客户来说是好事，分工明确了白；但对于工厂自己来说开销也变大了。
如要我想要生产核心芯片，但是芯片不是产品，不能继承于product类。因为产品和零部件，不是一类。
三. 抽象工厂模式
抽象工厂模式，它定义为提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
还以上面的例子解释，这家公司经营的还不错，针对其核心技术都申请了专利，后来生始生产相关电子芯片了 (像三星一样，即生产产品也生产芯片)。对于这种情况，我们不能在抽象产品类上继承一个零部件，因为产品和芯片没有什么共同之处，完全是两个领域。你要做芯片，就要专心做，当成一个新的领域，不能用以前产品的那一套流程。这样划分才明确，才能更好的实现高内聚，低耦合的明标。
[cpp] //抽象产品类
class Product
{
public:
virtual void Show() = 0;
};
//产品A
class ProductA: public Product
{
public:
void Show()
{
cout<<"Product A"<
};
//产品B
class ProductB: public Product
{
public:
void Show()
{
cout<<"Product B"<
};
//抽象芯片类
class Chip
{
public:
virtual void Show() = 0;
};
//芯片A
class ChipA: public Chip
{
public:
void Show()
{
cout<<"Chip A"<
};
//芯片B
class ChipB: public Chip
{
public:
void Show()
{
cout<<"Chip B"<
};