1Door* door = doorFactory->CreateDoor();

1class DoorFactory
2{
3public:
4  Door* CreateDoor()
5  {
6    return new Door();
7  }
8}

 1class CarManager
 2{
 3protected:
 4    AbstractFactory *abstractFactory;
 5public:
 6    //创造Car
 7    void createCar(AbstractFactory *abstractFactory)
 8    {
 9        abstractFactory->CreateEngine();
10        abstractFactory->CreateDoor();
11        abstractFactory->CreateLight();
12    }
13    //其他的操作
14    void run(){}
15};
16
17int _tmain(int argc, _TCHAR* argv[])
18{
19    CarManager *carManager = new CarManager();
20    //创建Classic风格的汽车
21    carManager->createCar(new ClassicFactory());
22
23    return 0;
24}

  1//
  2// AbstractFactoryTest for AbstractFactory Pattern Test
  3//
  4//
  5
  6#include "stdafx.h"
  7#include "iostream"
  8using namespace std;
  9
 10//Engine,Door,Light are the Abstract Product
 11//这三个类对应UML图中的AbstractProduct类
 12class Engine
 13{
 14public:
 15    Engine()
 16    {
 17        cout<<"Abstract Engine Create"<<endl;
 18    }
 19    virtual void doSomething() = 0;
 20};
 21
 22class Door
 23{
 24public:
 25    Door()
 26    {
 27        cout<<"Abstract Door Create"<<endl;
 28    }
 29    virtual void doSomething() = 0;
 30};
 31
 32class Light
 33{
 34public:
 35    Light()
 36    {
 37        cout<<"Abstract Light Create"<<endl;
 38    }
 39    virtual void doSomething() = 0;
 40};
 41
 42//Abstract Factory
 43class AbstractFactory
 44{
 45public:
 46    AbstractFactory()
 47    {
 48        cout<<"AbstractFactory Create"<<endl;
 49    }
 50    virtual Engine* CreateEngine() = 0;
 51    virtual Door* CreateDoor() = 0;
 52    virtual Light* CreateLight() = 0;
 53};
 54
 55//SpeedEngine,SpeedDoor,SpeedLight are the Products of Speed Style 
 56//这三个类对应UML图中的ProductA1，ProductB1，ProductC1类
 57class SpeedEngine:public Engine
 58{
 59public :
 60    SpeedEngine()
 61    {
 62        cout<<"Speed Engine Create"<<endl;
 63    }
 64    void doSomething(){    }
 65};
 66
 67class SpeedDoor:public Door
 68{
 69public :
 70    SpeedDoor()
 71    {
 72        cout<<"Speed Door Create"<<endl;
 73    }
 74    void doSomething(){    }
 75};
 76
 77class SpeedLight:public Light
 78{
 79public :
 80    SpeedLight()
 81    {
 82        cout<<"Speed Light Create"<<endl;
 83    }
 84    void doSomething(){    }
 85};
 86
 87//classicEngine,classicDoor,classicLight are the products of Classic style
 88//这三个类对应UML图中的ProductA2，ProductB2，ProductC2类
 89class ClassicEngine:public Engine
 90{
 91public :
 92    ClassicEngine()
 93    {
 94        cout<<"Classic Engine Create"<<endl;
 95    }
 96    void doSomething(){    }
 97};
 98
 99class ClassicDoor:public Door
100{
101public :
102    ClassicDoor()
103    {
104        cout<<"Classic Door Create"<<endl;
105    }
106    void doSomething(){    }
107};
108
109class ClassicLight:public Light
110{
111public :
112    ClassicLight()
113    {
114        cout<<"Classic Light Create"<<endl;
115    }
116    void doSomething(){    }
117};
118
119//Factory for Speed Cars
120//对应UML图中的ConcreteFactory1类
121class SpeedFactory:public AbstractFactory
122{
123public:
124    SpeedFactory()
125    {
126        cout<<"SpeedFactory Create"<<endl;
127    }
128    virtual Engine* CreateEngine()
129    {
130        return new SpeedEngine();
131    }
132    virtual Door* CreateDoor() 
133    {
134        return new SpeedDoor();
135    }
136    virtual Light* CreateLight()
137    {
138        return new SpeedLight();
139    }
140};
141
142//Factory for classic Cars
143//对应UML图中的ConcreteFactory2类
144class ClassicFactory:public AbstractFactory
145{
146public:
147    ClassicFactory()
148    {
149        cout<<"ClassicFactory Create"<<endl;
150    }
151    virtual Engine* CreateEngine()
152    {
153        return new ClassicEngine();
154    }
155    virtual Door* CreateDoor() 
156    {
157        return new ClassicDoor();
158    }
159    virtual Light* CreateLight()
160    {
161        return new ClassicLight();
162    }
163};
164
165//Client Code ---- use the Abstract Factory & Abstract Product to create the car
166//this is never changed
167class CarManager
168{
169protected:
170    AbstractFactory *abstractFactory;
171public:
172    //创造Car
173    void createCar(AbstractFactory *abstractFactory)
174    {
175        abstractFactory->CreateEngine();
176        abstractFactory->CreateDoor();
177        abstractFactory->CreateLight();
178    }
179    //其他的操作
180    void run(){}
181};
182
183int _tmain(int argc, _TCHAR* argv[])
184{
185    CarManager *carManager = new CarManager();
186    //创建Classic风格的汽车
187    carManager->createCar(new ClassicFactory());
188
189    return 0;
190}