AbstractFactory模式

抽象工厂模式，代码比较简洁。

Product.h

//Product.h#ifndef _PRODUCT_H_#define _PRODUCT_H_class AbstractProductA{public:AbstractProductA();virtual ~AbstractProductA();};class ProductA1 : public AbstractProductA{public:ProductA1();virtual ~ProductA1();};class ProductA2 : public AbstractProductA{public:ProductA2();virtual ~ProductA2();};/*==================================*/class AbstractProductB{public:AbstractProductB();virtual ~AbstractProductB();};class ProductB1 : public AbstractProductB{public:ProductB1();~ProductB1();};class ProductB2 : public AbstractProductB{public:ProductB2();~ProductB2();};#endif

Product.cpp

#include "Product.h"#include "iostream"using namespace std;AbstractProductA::AbstractProductA(){}AbstractProductA::~AbstractProductA(){}ProductA1::ProductA1(){cout<<"ProductA1"<<endl;}ProductA1::~ProductA1(){cout<<"~ProductA1"<<endl;}ProductA2::ProductA2(){cout<<"ProductA2"<<endl;}ProductA2::~ProductA2(){cout<<"~ProductA2"<<endl;}/*=====================================*/AbstractProductB::AbstractProductB(){}AbstractProductB::~AbstractProductB(){}ProductB1::ProductB1(){cout<<"ProductB1"<<endl;}ProductB1::~ProductB1(){cout<<"~ProductB1"<<endl;}ProductB2::ProductB2(){cout<<"ProductB2"<<endl;}ProductB2::~ProductB2(){cout<<"ProductB2"<<endl;}

AbstractFactory.h

//AbstractFactory.h#ifndef _ABSTRACTFACTORY_H_H#define _ABSTRACTFACTORY_H_H#include "Product.h"class AbstractFacroty{public:virtual ~AbstractFacroty();AbstractFacroty() ;virtual AbstractProductA * CreateProductA() = 0;virtual AbstractProductB * CreateProductB() = 0;};class ConcretFactory1 : public  AbstractFacroty{public:ConcretFactory1();~ConcretFactory1();virtual AbstractProductA * CreateProductA();virtual AbstractProductB * CreateProductB();};class ConcretFactory2 : public AbstractFacroty{ConcretFactory2();~ConcretFactory2();virtual AbstractProductA * CreateProductA();virtual AbstractProductB * CreateProductB();};#endif

AbstractFactory.cpp

//AbstractFactory.cpp#include "Product.h"#include "AbstractFactory.h"AbstractFacroty::AbstractFacroty(){}AbstractFacroty::~AbstractFacroty(){}ConcretFactory1::ConcretFactory1(){}ConcretFactory1::~ConcretFactory1(){}ConcretFactory2::ConcretFactory2(){}ConcretFactory2::~ConcretFactory2(){}AbstractProductA * ConcretFactory1::CreateProductA(){return new ProductA1();}AbstractProductA * ConcretFactory2::CreateProductA(){return new ProductA2();}AbstractProductB * ConcretFactory1::CreateProductB(){return new ProductB1();}AbstractProductB * ConcretFactory2::CreateProductB(){return new ProductB2();}

app.cpp

#include "AbstractFactory.h"int main(){AbstractFacroty * fac = new ConcretFactory1();delete fac->CreateProductA();delete fac->CreateProductB();return 0;}

怎么感觉同样的代码，C++的愣是比java的多这么多呢。。

抽象工厂模式为一组相关的类提供对象创建的接口，而工厂方法只是为一类对象封装了对象的创建。所以，如果对于存在大量统一类对象的系统，应该优先使用工厂方法，而对于存在大量复杂对象的系统，应使用抽象工厂方法。

他们有一个共同点是"将对象的实例化延迟到子类中实现"，对于这点，我觉得自己现在还没有理解到。