抽象工厂(Abstract Factory)

抽象工厂模式：提供了一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。这样客户就可以从具体的产品中被解耦.

要点：
1.抽象工厂使用对象组合：对象的创建被实现在工厂接口所暴露出来的方法中
2.抽象工厂创建相关的对象家族，而不需要依赖它们的具体类

关于简单工厂，工厂，抽象工厂的区别，从网上找到一个比较好的实例：
1.如果一个后花园只种蔬菜类,那么就用简单工厂就可以了.
2.如果后花园蔬菜品种繁多.得用工厂方法才可以,把共有的东西抽象出来.
3.如果要扩大后花园的规模,比如一个在北方,一个在南方,这样工厂方法就无法实现了,就应当用抽象工厂,把各种各样的植物,又组成一个后花园.
简单工厂是一个工厂只生产一类的产品,面对的是具体的类,工厂方法是可以生产不同的产品,把公共的方法抽象出来,然后进行创建各种各样的产品.抽象工厂把几种产品划出共同的东西,把相互依赖的对象抽象出来,只要实现这些接口就可以得到不同的产品.



Pizza.h

#ifndef PIZZA_H
#define PIZZA_H
#include"iostream"
#include"PizzaIngredientFactory.h"
using namespace std;
class Pizza{
public:
    explicit Pizza(PizzaIngredientFactory* pif){
        mPif = pif;
    }
    virtual void prepare(){
        cout << "prepare..." << endl;
    }
    virtual void bake(){
        cout << "bake..." << endl;
    }
    virtual void cut(){
        cout << "cut..." << endl;
    }
    virtual void box(){
        cout << "box..." << endl;
    }
private:
    PizzaIngredientFactory* mPif;
};

class CheesePizza:public Pizza{
public:
    explicit CheesePizza(PizzaIngredientFactory* pif):Pizza(pif),mPif(pif){
        mPif->createDough();
        mPif->createClam();
        cout << "this is a CheesePizza" << endl;
    }
private:
    PizzaIngredientFactory* mPif;
};

class VeggiePizza:public Pizza{
public:
    explicit VeggiePizza(PizzaIngredientFactory* pif):Pizza(pif),mPif(pif){
        mPif->createPepperoni();
        mPif->createClam();
        cout << "this is a CheesePizza" << endl;
    }
private:
    PizzaIngredientFactory* mPif;
};

class ClamPizza:public Pizza{
public:
    explicit ClamPizza(PizzaIngredientFactory* pif):Pizza(pif),mPif(pif){
        mPif->createDough();
        mPif->createVeggies();
        cout << "this is a CheesePizza" << endl;
    }
private:
    PizzaIngredientFactory* mPif;
};

class PepperonPizza:public Pizza{
public:
    explicit PepperonPizza(PizzaIngredientFactory* pif):Pizza(pif),mPif(pif){
        mPif->createPepperoni();
        mPif->createSauce();
        cout << "this is a CheesePizza" << endl;
    }
private:
    PizzaIngredientFactory* mPif;
};
#endif // PIZZA_H

PizzaStore.h

#ifndef PIZZASTORE_H
#define PIZZASTORE_H

#include"Pizza.h"

enum PizzaType{
    CHEESEPIZZA,
    VEGGIEPIZZA,
    CLAMPIZZA,
    PEPPERONIPIZZA
};

class PizzaStore{
public:
    explicit PizzaStore(){
    }
    void orderPizza(PizzaType pt){
        Pizza *pizza;
        pizza = createPizza(pt);
        pizza->prepare();
        pizza->bake();
        pizza->cut();
        pizza->box();
    }
    virtual Pizza* createPizza(PizzaType pt)=0;
};

class NYPizzaStore:public PizzaStore{
public:
    NYPizzaStore(){
        mPif = new NYPizzaIngredientFactory;
    }
    void orderPizza(PizzaType pt){
        Pizza *pizza;
        pizza = createPizza(pt);
        pizza->prepare();
        pizza->bake();
        pizza->cut();
        pizza->box();
    }
    Pizza* createPizza(PizzaType pt){
        switch(pt){
        case CHEESEPIZZA:
            return new CheesePizza(mPif);
            break;
        case VEGGIEPIZZA:
            return new VeggiePizza(mPif);
            break;
        case CLAMPIZZA:
            return new ClamPizza(mPif);
            break;
        case PEPPERONIPIZZA:
            return new PepperonPizza(mPif);
            break;
          default:
              return NULL;
              break;
        }
    }

private:
    PizzaIngredientFactory* mPif;
};

#endif // PIZZASTORE_H

PizzaIngredientFactory.h

#ifndef PIZZAINGREDIENTFACTORY_H
#define PIZZAINGREDIENTFACTORY_H
#include<iostream>
using namespace std;
//生面团
class Dough{};
//果酱
class Sauce{};
//蔬菜
class Veggies{};
//意大利辣味香肠
class Pepperoni{};
//蛤蜊
class Clam{};

//原料工厂
class PizzaIngredientFactory{
public:
    virtual void createDough()=0;
    virtual void createSauce()=0;
    virtual void createVeggies()=0;
    virtual void createPepperoni()=0;
    virtual void createClam()=0;
};

class NYPizzaIngredientFactory:public PizzaIngredientFactory{
public:
    void createDough(){
        cout << "create dough.." << endl;
    }
    void createSauce(){
        cout << "create sauce.." << endl;
    }
    void createVeggies(){
        cout << "create veggies.." << endl;
    }
    void createPepperoni(){
        cout << "create popperoni.." << endl;
    }
    void createClam(){
        cout << "create clam.." << endl;
    }
};

#endif // PIZZAINGREDIENTFACTORY_H

main.cpp

#include"PizzaStore.h"

int main(){
    PizzaStore *store = new NYPizzaStore();
    store->orderPizza(CHEESEPIZZA);
}

create dough..
create clam..
this is a CheesePizza
prepare...
bake...
cut...
box...

另一份代码:



SimpleFactory.h

#ifndef SIMPLEFACTORY_H
#define SIMPLEFACTORY_H

class Fruit
{

};

class Apple:public Fruit
{

};

class Pear:public Fruit
{

};

class Orange:public Fruit
{

};

enum FRUIT_TYPE
{
    APPLE,
    PEAR,
    ORANGE
};

class Land
{
public:
    Land()
    {
        mApple = new Apple;
        mPear = new Pear;
        mOrange = new Orange;
    }

    ~Land(){}

    Fruit* create(int fruitType)
    {
        switch(fruitType)
        {
        case APPLE:
            return mApple;
        case PEAR:
            return mPear;
        case ORANGE:
            return mOrange;
        default:
            return 0;
        }
    }
private:
    Apple* mApple;

    Pear* mPear;

    Orange* mOrange;
};

#endif // SIMPLEFACTORY_H

FactoryMethod.h

#ifndef FACTORYMETHOD_H
#define FACTORYMETHOD_H

namespace FactoryMethod
{

class Fruit{};

class Apple:public Fruit{};

class Apple1:public Apple{};

class Apple2:public Apple{};

class Apple3:public Apple{};

class Land
{
public:
    virtual Fruit* create()=0;
};

class AppleLand:public Land
{
public:
    AppleLand()
    {
        mApple = new Apple;
    }

    ~AppleLand(){}

    Fruit* create()
    {
        return mApple;
    }
private:
    Apple* mApple;
};

}//end of namespace FactoryMethod

#endif // FACTORYMETHOD_H

AbstractFactory.h

#ifndef ABSTRACTFACTORY_H
#define ABSTRACTFACTORY_H

namespace AbstractFactory
{

class Fruit{};

class Apple:public Fruit{};

class Apple1:public Apple{};

class Apple2:public Apple{};

class Apple3:public Apple{};

class Land
{
public:
    virtual Fruit* createType1()=0;
    virtual Fruit* createType2()=0;
    virtual Fruit* createType3()=0;
};

class Apple1Land:public Land
{
public:
    Apple1Land()
    {
        mApple1 = new Apple1;
        mApple2 = new Apple2;
        mApple3 = new Apple3;
    }

    ~Apple1Land(){}

    Fruit* createType1(){
        return mApple1;
    }
    Fruit* createType2(){
        return mApple2;
    }
    Fruit* createType3(){
        return mApple3;
    }
private:
    Apple* mApple1;

    Apple* mApple2;

    Apple* mApple3;
};

}//end of namespace AbstractFactory

#endif // ABSTRACTFACTORY_H

main.cpp

#include "SimpleFactory.h"
#include "FactoryMethod.h"
#include "AbstractFactory.h"

int main()
{
    Land* land = new Land;
    land->create(APPLE);

    FactoryMethod::Land* appleLand = new FactoryMethod::AppleLand;
    appleLand->create();

    AbstractFactory::Land* apple1Land = new AbstractFactory::Apple1Land;
    apple1Land->createType1();
}