本文大部分从网络摘抄，出处就不一一列明了，原作者还请见谅.
Factory与Abstract Factory模式的区别：
Factory模式概述：
一个抽象产品类，可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类只能创建一个具体产品类的实例。
Abstract Factory模式概述：
多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类可以创建多个具体产品类的实例。
区别：
Factory模式只有一个抽象工厂类，而Abstract Factory有多个， Factory模式的具体工厂类只能创建一个具体产品类的实例，而Abstract Factory模式的具体工厂类可以创建多个具体产品类的实例。
Factory模式：
作用：定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory method使一个类的实例化延迟到其子类。
Factory解决的问题：
问题1：为了提高内聚（Cohesion）和松耦合（Coupling），我们经常会抽象出一些类的公共接口以形成抽象基类或者接口。这样我们可以通过声明一个指向基类的指针来指向实际的子类，以达到多态的目的。这里很容易出现的一个问题就是n多的子类继承自抽象基类，我们不得不在每次要用到子类的地方都要编写诸如new xxx的代码。这里带来了两个问题：1.客户程序员必须知道实际子类的名称（当系统复杂后，命名将是一个很不好处理的问题，为了处理可能名字冲突，有的命名可能并不是具有很好的可读性和可记忆性）。2.程序的扩展性和维护性将变得越来越困难。
问题2：
父类中并不知道要具体实例化哪一个具体的子类。即A类用到抽象基类B，但是A并不知道要实例化B的哪一个子类，但是A类的子类C知道。在A中我们没有办法直接使用new xxx这样的语句来创建，因为我们根本就不知道new什么。
Factory模式：
作用是，定义一个用于创建对象的借口，让子类决定实例化哪一个类，Factory Method使一个类的实例化延迟到其子类:
#ifndef FACOTRY_H__
#define FACTROY_H__class Product
{
public:
Product(){}
virtual ~Product(){}
};
class ConcreateProduct
:public Product
{
public:
ConcreateProduct();
virtual ~ConcreateProduct();
};
class Factory
{
public:
Factory(){}
virtual ~Factory(){}
void AnOperation();
protected:
virtual Product* FactoryMethod() = 0;
};
class ConcreateFactory : public Factory
{
public:
ConcreateFactory();
virtual ~ConcreateFactory();
protected:
virtual Product* FactoryMethod();
};
#endif
抽象工厂设计模式
作用：提供一个创建一系列相关或相互依赖对象的借口，而无需制定他们具体的类。
#pragma once
class AbstractProductA
{
public:
AbstractProductA() {};
virtual ~AbstractProductA(){};
};
class ConcreateProductA1: public AbstractProductA
{
public:
ConcreateProductA1();
virtual ~ConcreateProductA1();
};
class ConcreateProductA2 : public AbstractProductA
{
public:
ConcreateProductA2();
virtual ~ConcreateProductA2();
};
class AbstractProductB
{
public:
AbstractProductB() {}
virtual ~AbstractProductB(){}
};
class ConcreateProductB1 : public AbstractProductB
{
public:
ConcreateProductB1();
virtual ~ConcreateProductB1();
};
class ConcreateProductB2 : public AbstractProductB
{
public:
ConcreateProductB2();
virtual ~ConcreateProductB2();
};
//抽?象?基?类?AbstractFactory，?工?厂?的?抽?象?类?，?生?产?产?品?A和?产?品?B
class AbstractFactory
{
public:
AbstractFactory(){}
virtual ~AbstractFactory() {}
virtual AbstractProductA *CreateProductA() = 0;
virtual AbstractProductB *CreateProductB() = 0;
};
//派?生?类?ConcreateFactory1,继?承?自?AbstractFactory
//生?产?产?品?A和?产?品?B的?第?一?种?实?现?
class ConcreateFactory1 : public AbstractFactory
{
public:
ConcreateFactory1();
virtual ~ConcreateFactory1();
virtual AbstractProductA* CreateProductA();
virtual AbstractProductB* CreateProductB();
};
class ConcreateFactory2 : public AbstractFactory
{
public:
ConcreateFactory2();
virtual ~ConcreateFactory2();
virtual AbstractProductA* CreateProductA();
virtual AbstractProductB* CreateProductB();
};