1 ///////////////////////Product.h////////////// 2 #ifndef _PRODUCT_H_ 3 #define _PRODUCT_H_ 4 class AbstractProductA 5 { 6 public: 7 virtual ~AbstractProductA(); 8 protected: 9 AbstractProductA(); 10 private: 11 }; 12 13 14 class AbstractProductB 15 { 16 public: 17 virtual ~AbstractProductB(); 18 protected: 19 AbstractProductB(); 20 private: 21 }; 22 23 class ProductA1 : public AbstractProductA 24 { 25 public: 26 ~ProductA1(); 27 ProductA1(); 28 protected: 29 private: 30 }; 31 32 class ProductA2 : public AbstractProductA 33 { 34 public: 35 ~ProductA2(); 36 ProductA2(); 37 protected: 38 private: 39 }; 40 41 class ProductB1 : public AbstractProductB 42 { 43 public: 44 ~ProductB1(); 45 ProductB1(); 46 protected: 47 private: 48 }; 49 50 class ProductB2 : public AbstractProductB 51 { 52 public: 53 ~ProductB2(); 54 ProductB2(); 55 protected: 56 private: 57 }; 58 59 #endif
1 ///////////////////////Product.cpp////////////// 2 #include "Product.h" 3 #include <iostream> 4 using namespace std; 5 6 AbstractProductA::~AbstractProductA() 7 { 8 9 } 10 AbstractProductA::AbstractProductA() 11 { 12 13 } 14 AbstractProductB::~AbstractProductB() 15 { 16 17 } 18 AbstractProductB::AbstractProductB() 19 { 20 21 } 22 23 ProductA1::~ProductA1() 24 { 25 26 } 27 ProductA1::ProductA1() 28 { 29 cout<<"ProductA1"<<endl; 30 } 31 32 ProductA2::~ProductA2() 33 { 34 35 } 36 ProductA2::ProductA2() 37 { 38 cout<<"ProductA2"<<endl; 39 } 40 41 ProductB1::~ProductB1() 42 { 43 44 } 45 ProductB1::ProductB1() 46 { 47 cout<<"ProductB1"<<endl; 48 } 49 ProductB2::~ProductB2() 50 { 51 52 } 53 ProductB2::ProductB2() 54 { 55 cout<<"ProductB2"<<endl; 56 }
1 ///////////////////////Factory.h////////////// 2 #ifndef _FACTORY_H_ 3 #define _FACTORY_H_ 4 5 class AbstractProductA; 6 class AbstractProductB; 7 8 class AbstractFactory 9 { 10 public: 11 virtual ~AbstractFactory(); 12 virtual AbstractProductA* CreatProductA()=0; 13 virtual AbstractProductB* CreatProductB()=0; 14 protected: 15 AbstractFactory(); 16 private: 17 }; 18 19 class ConcreteFactory1 : public AbstractFactory 20 { 21 public: 22 ~ConcreteFactory1(); 23 ConcreteFactory1(); 24 AbstractProductA* CreatProductA(); 25 AbstractProductB* CreatProductB(); 26 protected: 27 private: 28 }; 29 30 31 class ConcreteFactory2 : public AbstractFactory 32 { 33 public: 34 ~ConcreteFactory2(); 35 ConcreteFactory2(); 36 AbstractProductA* CreatProductA(); 37 AbstractProductB* CreatProductB(); 38 protected: 39 private: 40 }; 41 42 #endif
1 ///////////////////////Factory.cpp////////////// 2 #include "Factory.h" 3 #include "Product.h" 4 5 AbstractFactory::~AbstractFactory() 6 { 7 8 } 9 AbstractFactory::AbstractFactory() 10 { 11 12 } 13 14 ConcreteFactory1::~ConcreteFactory1(){} 15 ConcreteFactory1::ConcreteFactory1(){} 16 AbstractProductA* ConcreteFactory1::CreatProductA() 17 { 18 return new ProductA1(); 19 } 20 21 AbstractProductB* ConcreteFactory1::CreatProductB() 22 { 23 return new ProductB1(); 24 } 25 26 27 ConcreteFactory2::~ConcreteFactory2(){} 28 ConcreteFactory2::ConcreteFactory2(){} 29 AbstractProductA* ConcreteFactory2::CreatProductA() 30 { 31 return new ProductA2(); 32 } 33 34 AbstractProductB* ConcreteFactory2::CreatProductB() 35 { 36 return new ProductB2(); 37 }
1 ///////////////////////main.cpp////////////// 2 #include "Factory.h" 3 #include <iostream> 4 5 int main() 6 { 7 AbstractFactory* fac1 = new ConcreteFactory1(); 8 fac1->CreatProductA(); 9 fac1->CreatProductB(); 10 11 AbstractFactory* fac2 = new ConcreteFactory2(); 12 fac2->CreatProductA(); 13 fac2->CreatProductB(); 14 15 getchar(); 16 17 return 0; 18 }