【C++】Chapter11：抽象工厂模式

先说下之前用到过的【工厂方法模式】是定义一个用于创建对象的接口。让子类决定实例化哪一个类。

再说【抽象工厂模式（Abstract Factory）】，提供一个创建一系列相关或者相互依赖对象的接口，而无需指定它们具体的类。

 

代码工程结构：

（1）产品A  ProductA.h

（2）产品B  ProductB.h

（3）工厂类 Factory.h

（4）客户端 AbstractFactoryApp.cpp

（1）产品A  ProductA.h

#ifndef _PRODUCT_A_ #define _PRODUCT_A_ #include <iostream> using namespace std; class AbstractProductA { public: virtual void GetA(void) = 0; }; class ProductA1 : public AbstractProductA { void GetA(void) { cout << "Product1的GetA方法/n"; } }; class ProductA2 : public AbstractProductA { void GetA(void) { cout << "Product2的GetA方法/n"; } }; #endif _PRODUCT_A_

 

 

（2）产品B  ProductB.h

#ifndef _PRODUCT_B_ #define _PRODUCT_B_ #include <iostream> using namespace std; class AbstractProductB { public: virtual void GetB(void) = 0; }; class ProductB1 : public AbstractProductB { void GetB(void) { cout << "Product1的GetB方法/n"; } }; class ProductB2 : public AbstractProductB { void GetB(void) { cout << "Product2的GetB方法/n"; } }; #endif _PRODUCT_B_

 

 

（3）工厂类 Factory.h

#ifndef _FACTORY_H_ #define _FACTORY_H_ #include "ProductA.h" #include "ProductB.h" class AbstractFactory { public: virtual AbstractProductA* CreateProductA() = 0; virtual AbstractProductB* CreateProductB() = 0; }; class ConcreteFactory1 : public AbstractFactory { public: ProductA1* CreateProductA() { m_pProductA1 = new ProductA1(); return m_pProductA1; } ProductB1* CreateProductB() { m_pProductB1 = new ProductB1(); return m_pProductB1; } private: ProductA1* m_pProductA1; ProductB1* m_pProductB1; }; class ConcreteFactory2 : public AbstractFactory { public: ProductA2* CreateProductA() { m_pProductA2 = new ProductA2(); return m_pProductA2; } ProductB2* CreateProductB() { m_pProductB2 = new ProductB2(); return m_pProductB2; } private: ProductA2* m_pProductA2; ProductB2* m_pProductB2; }; #endif _FACTORY_H_

 

（4）客户端 AbstractFactoryApp.cpp

 // AbstractFactoryApp.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include "Factory.h" void FreeMemory(void* Pointer) { if (NULL != Pointer) { free(Pointer); } } int _tmain(int argc, _TCHAR* argv[]) { // 只需要确定实例化哪一个Product对象给factory，这里我们用ConcreteFactory1来初始化 // AbstractFactory* pFactory = new ConcreteFactory2(); AbstractFactory* pFactory = new ConcreteFactory1(); // 此时与具体的Product访问解除了依赖 AbstractProductA* pProductA = pFactory->CreateProductA(); pProductA->GetA(); AbstractProductB* pProductB = pFactory->CreateProductB(); pProductB->GetB(); system("pause"); FreeMemory(pFactory); return 0; }

 

抽象工厂模式的优点和缺点：

最大的好处便是易于交换产品系列，由于具体工厂类，例如 AbstractFactory* pFactory = new ConcreteFactory1(), 在一个应用中只需要在初始化的时候出现一次，这就使得改变一个应用的具体工厂变得非常容易，它只需要改变具体工厂即可使用不同的产品配置。我们的设计不能去防止需求的改变，那么我们的理想便是让改动变得最小。

第二大好处是，它让具体的创建实例过程与客户端分离，客户端是通过它们的抽象接口操纵实例，产品的具体类名也被具体工厂的实现分离，不会出现在客户端代码中。

缺点是：如果你的需求来自增加功能，比如我们现在要增加新的 AbstractProductC，我们需要改动哪些地方？至少要增加三个类AbstractProductC、ProductC1、ProductC2才可以完全实现。

 

 

用简单工厂来改进抽象工厂

去除AbstractFactory、ConcreteFactory1、ConcreteFactory2三个工厂类，取而代之的是ProductAccess类，用一个简单工厂模式来实现。

 

工程结构

（1）产品A   ProductA.h

（2）产品B   ProductB.h

（3）产品创建控制   ProductAccess.h

（4）客户端   ReflectionApp.cpp

 

（1）产品A   ProductA.h

#ifndef _PRODUCT_A_ #define _PRODUCT_A_ #include <iostream> using namespace std; class AbstractProductA { public: virtual void GetA(void) = 0; }; class ProductA1 : public AbstractProductA { void GetA(void) { cout << "Product1的GetA方法/n"; } }; class ProductA2 : public AbstractProductA { void GetA(void) { cout << "Product2的GetA方法/n"; } }; #endif _PRODUCT_A_

 

（2）产品B   ProductB.h

#ifndef _PRODUCT_B_ #define _PRODUCT_B_ #include <iostream> using namespace std; class AbstractProductB { public: virtual void GetB(void) = 0; }; class ProductB1 : public AbstractProductB { void GetB(void) { cout << "Product1的GetB方法/n"; } }; class ProductB2 : public AbstractProductB { void GetB(void) { cout << "Product2的GetB方法/n"; } }; #endif _PRODUCT_B_

 

（3）产品创建控制   ProductAccess.h

#ifndef _PRODUCT_ACCESS_H_ #define _PRODUCT_ACCESS_H_ #include <string> #include <map> using namespace std; /************************************************************************ * description: 实现了注册类实例指针及其类名字符串的类模版 * remark: ************************************************************************/ template<class TBase, typename ClassID = string> class CFactory { private: CFactory(){} CFactory(const CFactory&){} CFactory& operator=(const CFactory&){} typedef TBase*(*BasePtr)(); map<ClassID, BasePtr> m_mapRegInfo; public: static CFactory& Instance() { static CFactory<TBase, ClassID> bf; return bf; } // 实现注册<类名, 类实例指针> void RegBasePtr(const ClassID& classname, BasePtr fn) { m_mapRegInfo[classname] = fn; } // 实现通过类名获取其实例指针。如果未注册则返回空指针 TBase* GetRegPtr(const ClassID& classname) const { TBase* BaseObj = NULL; map<ClassID, BasePtr>::const_iterator regEntry = m_mapRegInfo.find(classname); if (regEntry != m_mapRegInfo.end()) { BaseObj = regEntry->second(); } return BaseObj; } }; // 调用CFactory<BASE_CLASS>类类型的静态成员函数通过类名获取对应的实例指针，如果该类名没有注册过，返回空指针 #define CREATE_CLASS(BASE_CLASS, DERIVED_CLASS) CFactory<BASE_CLASS>::Instance().GetRegPtr(DERIVED_CLASS) /************************************************************************ * description: 执行注册类实例指针以及对应的类名信息的类模版 * remark: ************************************************************************/ template<class TBase, class TDerived, typename ClassID = string> class RegToFactory { public: static TBase* CreateInstance() { return (new TDerived()); } RegToFactory(const ClassID& id) { CFactory<TBase, ClassID>::Instance().RegBasePtr(id, CreateInstance); } }; // 定义一个RegToFactory<BASE_CLASS, DERIVED_CLASS>类类型的对象Register##DERIVED_CLASS，在执行构造函数时带入类名对应的字符串 #define REGISTER_CLASS(BASE_CLASS, DERIVED_CLASS) RegToFactory<BASE_CLASS, DERIVED_CLASS> Register##DERIVED_CLASS(#DERIVED_CLASS) #endif// _PRODUCT_ACCESS_H_

 

（4）客户端   ReflectionApp.cpp

// ReflectionApp.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include "ProductAccess.h" #include "ProductA.h" #include "ProductB.h" REGISTER_CLASS(AbstractProductA, ProductA1); REGISTER_CLASS(AbstractProductA, ProductA2); REGISTER_CLASS(AbstractProductB, ProductB1); REGISTER_CLASS(AbstractProductB, ProductB2); int _tmain(int argc, _TCHAR* argv[]) { AbstractProductA* pBaseA = NULL; AbstractProductB* pBaseB = NULL; pBaseA = CREATE_CLASS(AbstractProductA, "ProductA1"); if (NULL != pBaseA) { pBaseA->GetA(); delete pBaseA; pBaseA = NULL; } pBaseB = CREATE_CLASS(AbstractProductB, "ProductB1"); if (NULL != pBaseB) { pBaseB->GetB(); delete pBaseB; pBaseB = NULL; } system("pause"); return 0; }

 

看到这里不知道你发现了没？这个工程里用到了一个在C#或JAVA里很出名的特性：反射

摘自MSDN上对反射的定义：反射提供了封装程序集、模块和类型的对象（Type类型）。可以使用反射动态创建类型的实例，将类型绑定到现有对象，或从现有对象获取类型并调用其方法或访问其字段和属性。如果代码中使用了属性，可以利用反射对它们进行访问。

 

在这里我参考了网上牛人们的代码，用C++简单的实现了反射。或许说这种反射是个“形似神不似的反射”。

因为在C#和JAVA中的反射远比“这里的反射”功能强大的多。