AbstractFactory模式就是用来解决这类问题的:要创建一组相关或者相互依赖的对象。 #pragma once //Product.h #ifndef _PRODUCT_H_ #define _PRODUCT_H_ // 假定:产品类别A、B。 // 通过A、B我们可以得到一系列产品组合: // 产品系列: A1、B1 // 产品系列: A2、B2 // 抽象产品A class AbstractProductA { public: virtual ~AbstractProductA(); protected: AbstractProductA(); private: }; // 抽象产品B class AbstractProductB { public: virtual ~AbstractProductB(); protected: AbstractProductB(); private: }; // 产品A1 class ProductA1:public AbstractProductA { public: ProductA1(); virtual ~ProductA1(); protected: private: }; // 产品A2 class ProductA2:public AbstractProductA { public: ProductA2(); virtual ~ProductA2(); protected: private: }; // 产品B1 class ProductB1:public AbstractProductB { public: ProductB1(); virtual ~ProductB1(); protected: private: }; // 产品B2 class ProductB2:public AbstractProductB { public: ProductB2(); virtual ~ProductB2(); protected: private: }; #endif // _PRODUCT_H_ #include "StdAfx.h" //Product.cpp #include "Product.h" #include <iostream> using namespace std; // 抽象产品A AbstractProductA::AbstractProductA() { } AbstractProductA::~AbstractProductA() { } // // 抽象产品B AbstractProductB::AbstractProductB() { } AbstractProductB::~AbstractProductB() { } // // 产品A1、A2 ProductA1::ProductA1() { cout<<"ProductA1..."<<endl; } ProductA1::~ProductA1() { } ProductA2::ProductA2() { cout<<"ProductA2..."<<endl; } ProductA2::~ProductA2() { } // // 产品B1、B2 ProductB1::ProductB1() { cout<<"ProductB1..."<<endl; } ProductB1::~ProductB1() { } ProductB2::ProductB2() { cout<<"ProductB2..."<<endl; } ProductB2::~ProductB2() { } #pragma once //AbstractFactory.h #ifndef _ABSTRACTFACTORY_H_ #define _ABSTRACTFACTORY_H_ class AbstractProductA; class AbstractProductB; // 抽象工厂 -- 定义产品创建的接口 class AbstractFactory { public: virtual ~AbstractFactory(); virtual AbstractProductA* CreateProductA() = 0; virtual AbstractProductB* CreateProductB() = 0; protected: AbstractFactory(); private: }; // 具体工厂1 -- 负责生产一组相关的系列产品 class ConcreteFactory1:public AbstractFactory { public: ConcreteFactory1(); virtual ~ConcreteFactory1(); public: AbstractProductA* CreateProductA(); AbstractProductB* CreateProductB(); protected: private: }; // 具体工厂2 -- 负责生产一组相关的系列产品 class ConcreteFactory2:public AbstractFactory { public: ConcreteFactory2(); virtual ~ConcreteFactory2(); public: AbstractProductA* CreateProductA(); AbstractProductB* CreateProductB(); protected: private: }; #endif //~_ABSTRACTFACTORY_H_ #include "StdAfx.h" //AbstractFactory.cpp #include "AbstractFactory.h" #include "Product.h" #include <iostream> using namespace std; AbstractFactory::AbstractFactory() { } AbstractFactory::~AbstractFactory() { } ConcreteFactory1::ConcreteFactory1() { } ConcreteFactory1::~ConcreteFactory1() { } // 创建产品A1、B1 AbstractProductA* ConcreteFactory1::CreateProductA() { return new ProductA1(); } AbstractProductB* ConcreteFactory1::CreateProductB() { return new ProductB1(); } ConcreteFactory2::ConcreteFactory2() { } ConcreteFactory2::~ConcreteFactory2() { } // 创建产品A2、B2 AbstractProductA* ConcreteFactory2::CreateProductA() { return new ProductA2(); } AbstractProductB* ConcreteFactory2::CreateProductB() { return new ProductB2(); } // AbstractFactory_Pattern.cpp : Defines the entry point for the console application. // #include "stdafx.h" //main.cpp #include "AbstractFactory.h" #include <iostream> using namespace std; int main(int argc,char* argv[]) { // 第一组产品工厂 -- 一个产品系列组合 AbstractFactory* cf1 = new ConcreteFactory1(); AbstractProductA* pProductA1 = cf1->CreateProductA(); // 产品A1 AbstractProductB* pProductB1 = cf1->CreateProductB(); // 产品B1 // 第二组产品工厂 -- 一个产品系列组合 AbstractFactory* cf2 = new ConcreteFactory2(); AbstractProductA* pProductA2 = cf2->CreateProductA(); // 产品A2 AbstractProductB* pProductB2 = cf2->CreateProductB(); // 产品B2 return 0; }