What is it?
工厂模式：是一种很常见创建型模式，是用工厂代替new操作的模式。在java程序中很常见，但C++同样可以实现和使用。因为工厂模式就相当于创建对象时的new，如A a = new A();所以用我们在用new时要考虑能不能用工厂模式。虽然这样做，可能多做一些工作，但会给你系统带来更大的可扩展性和尽量少的修改量。。
工厂模式可分为“简单工厂模式”和“抽象工厂模式”。
Why use it?（简单工厂模式）
①为了提高内聚（Cohesion）和松耦合（Coupling），我们经常会抽象出一些类的公共接口以形成抽象基类或者接口。这样我们可以通过声明一个指向基类的指针来指向实际的子类实现，达到了多态的目的。这里很容易出现的一个问题 n 多的子类继承自抽象基类，我们不得不在每次要用到子类的地方就编写诸如 new ×××;的代码。这里带来两个问题 1）客户程序员必须知道实际子类的名称（当系统复杂后，命名将是一个很不好处理的问题，为了处理可能的名字冲突，有的命名可能并不是具有很好的可读性和可记忆性，就姑且不论不同程序员千奇百怪的个人偏好了。），2）程序的扩展性和维护变得越来越困难。
②还有一种情况就是在父类中并不知道具体要实例化哪一个具体的子类。这里的意思为：假设我们在类 A 中要使用到类 B，B 是一个抽象父类，在 A 中并不知道具体要实例化那一个 B 的子类，但是在类 A 的子类 D 中是可以知道的。在 A 中我们没有办法直接使用类似于 new ×××的语句，因为根本就不知道×××是什么。
上图这种简单工厂模式 定义创建对象的接口，封装了对象的创建；
而这种简单工厂模式 并不是只是为了封装对象的创建，使得具体化类的工作延迟到了子类中。
第②种的实现如下：【首先你要定义产品接口，如上面的product类的接口,产品接口下有product接口的实现类,如concreteproduct1,其次要有一个Factory类的接口，工厂接口下有factory类的接口的实现类，如concretefactory,是用来生成产品product接口的具体实例。】
class Product
{
public:
Product(string name = "") :mname(name)
{
}
virtual void Show() = 0;
virtual ~Product(){}
protected:
string mname;
};
class Product_A : public Product
{
public:
Product_A(string name) :Product(name){}
virtual void Show()
{
cout << "Product_A::name:" << mname << endl;
}
};
class Product_B : public Product
{
public:
Product_B(string name) :Product(name){}
virtual void Show()
{
cout << "Product_B::name:" << mname << endl;
}
};
class factory
{
public:
factory(){}
virtual ~factory() = 0;
virtual product* createA(int flag) = 0;
virtual product* createB(int flag) = 0;
}
class concretefactory::public factory
{
public:
concreatefactory(){}
~concreatefactory(){}
Product* createA(int flag)
{
return new Product_A("A");
}
Product* createB(int flag)
{
return new Product_B("B");
}
};
int main()
{
Factory fin;
Product* fout = fin.createA();//产品基类指向产品派生类新对象。
fout->show();
Fout = fin.createB();
Fout->show();
delete fout;
return 0;
}Why use it?（抽象工厂模式）
假设我们要开发一款游戏，当然为了吸引更多的人玩，游戏难度不能太大（让大家都没有信心了，估计游戏也就没有前途了），但是也不能太简单（没有挑战性也不符合玩家的心理）。于是我们就可以采用这样一种处理策略：为游戏设立等级，初级、中级、高级甚至有BT 级。假设也是过关的游戏，每个关卡都有一些怪物（monster）守着，玩家要把这些怪物干掉才可以过关。作为开发者，我们就不得不创建怪物的类，然后初级怪物、中级怪物等都继承自怪物类（当然不同种类的则需要另创建类，但是模式相同）。在每个关卡，我们都要创建怪物的实例，例如初级就创建初级怪物（有很多种类）、中级创建中级怪物等。可以想象在这个系统中，将会有成千上万的怪物实例要创建，问题是还要保证创建的时候不会出错： 初级不能创建 BT 级的怪物（玩家就郁闷了，玩家一郁闷，游戏也就挂挂了），反之也不可以。
【总结一下：假如一个游戏运行时，那么我们闯每一关时将可能调用初级、中级或高级动物类的相应的经验值类、生命值类、伤害类等的实例。factory工厂类就相当于初级、中级或高级动物类，product类相当于经验值、生命值、伤害类】
AbstractFactory 模式就是用来解决这类问题的：要创建一组相关或者相互依赖的对象。
实现如下：【定义一个创建对象的抽象类（工厂类），共同部分封装在抽象类中,不同部分使用子类实现，具有多个产品接口。让产品类的子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行】。
class pa
{
public:
pa(string name = "") :mname(name){}
~pa(){}
virtual void Operator() = 0;
protected:
string mname;
};
class pa1 : public pa
{
public:
pa1(string name) :pa(name){}
void Operator()
{
cout << "pa1::Operator()" << endl;
}
};
class pa2 : public pa
{
public:
pa2(string name) :pa(name){}
void Operator()
{
cout << "pa2::Operator()" << endl;
}
};
class pb
{
public:
B(string name = "") :mname(name){}
~B(){}
virtual void Operator() = 0;
protected:
string mname;
};
class pb1 : public pb
{
public:
pb1(string name) :pb(name){}
void Operator()
{
cout << "pb1::Operator()" << endl;
}
};
class pb2 : public pb
{
public:
pb2(string name) :pb(name){}
void Operator()
{
cout << "pb2::Operator()" << endl;
}
};
class Factory
{
public:
virtual pa* createPa() = 0;
virtual pb* createPb() = 0;
};
class Factory_1 : public Factory
{
public:
pa* createPa()
{
return new pa1("pa1");
}
pb* createPb()
{
return new pb1("Pb1");
}
};
class Factory_2 : public Factory
{
public:
pa* createPa()
{
return new pa2("pa2");
}
pb* createB()
{
return new pb2("pb2");
}
};
int main()
{
Factory_2 f2;//工厂的2生产线（产出一族相关的产品）
pa* paa = f2.createPa();//2生产线的A创建方法（产出一类相关产品）
paa->Operator();
return 0;
}