//Product.h#ifndef _PRODUCT_H_ //避免多次编译#define _PRODUCT_H_class Product{public:virtual ~Product() = 0;protected:Product();//屏蔽构造函数};class ConcreteProduct :public Product{public:ConcreteProduct();~ConcreteProduct();};#endif //~_PRODUCT_H_//Product.cpp#include "Product.h"#include <iostream>using namespace std;Product::Product(){}Product::~Product(){}ConcreteProduct::ConcreteProduct(){cout << "ConcreteProduct..." << endl;}ConcreteProduct::~ConcreteProduct(){}
//Factory.h#ifndef _FACTORY_H_ #define _FACTORY_H_class Product;class Factory {public: virtual ~Factory() = 0;virtual Product* CreateProduct() = 0;protected: Factory();};class ConcreteFactory :public Factory {public:~ConcreteFactory();ConcreteFactory();Product* CreateProduct();};#endif
//Factory.cpp#include "Factory.h"#include "Product.h"#include <iostream> using namespace std;Factory::Factory() {}Factory::~Factory() {}ConcreteFactory::ConcreteFactory() {cout << "ConcreteFactory....." << endl; }ConcreteFactory::~ConcreteFactory() {}Product* ConcreteFactory::CreateProduct(){return new ConcreteProduct();}
//main.cpp#include "Factory.h" #include "Product.h"#include <iostream> using namespace std;int main(){Factory* fac = new ConcreteFactory();Product* p = fac->CreateProduct();return 0;}
示例代码中给出的是Factory模式解决父类中并不知道具体要实例化哪一个具体的子类的问题，至于为创建对象提供接口问题，可以由Factory中附加相应的创建操作例如Create***Product（）即可
AbstractFactory 模式
AbstractFactory模式关键就是将这一组对象的创建封装到一个用于创建对象的类（ConcreteFactory）中，维护这样一个创建类总比维护n多相关对象的创建过程要简单的多。
//AProduct.h#ifndef _APRODUCT_H_ #define _APRODUCT_H_class AbstractProductA {public: virtual ~AbstractProductA();protected:AbstractProductA();};class AbstractProductB {public: virtual ~AbstractProductB();protected: AbstractProductB();};class ProductA1 :public AbstractProductA {public: ProductA1();~ProductA1();};class ProductA2 :public AbstractProductA {public: ProductA2();~ProductA2();};class ProductB1 :public AbstractProductB {public: ProductB1();~ProductB1();};class ProductB2 :public AbstractProductB {public:ProductB2();~ProductB2();};#endif//AProduct.cpp#include "AProduct.h"#include <iostream> using namespace std;AbstractProductA::AbstractProductA() {}AbstractProductA::~AbstractProductA() {}AbstractProductB::AbstractProductB() {}AbstractProductB::~AbstractProductB() {}ProductA1::ProductA1() {cout << "ProductA1..." << endl; }ProductA1::~ProductA1() {}ProductA2::ProductA2() {cout << "ProductA2..." << endl; }ProductA2::~ProductA2(){}ProductB1::ProductB1(){cout << "ProductB1..." << endl;}ProductB1::~ProductB1() {}ProductB2::ProductB2() {cout << "ProductB2..." << endl;}ProductB2::~ProductB2() {}//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();};class ConcreteFactory1 :public AbstractFactory {public:ConcreteFactory1();~ConcreteFactory1();AbstractProductA* CreateProductA();AbstractProductB* CreateProductB();};class ConcreteFactory2 :public AbstractFactory {public:ConcreteFactory2();~ConcreteFactory2();AbstractProductA* CreateProductA();AbstractProductB* CreateProductB();};#endif
//AbstractFactory.cpp#include "AbstractFactory.h" #include "AProduct.h"#include <iostream> using namespace std;AbstractFactory::AbstractFactory() {}AbstractFactory::~AbstractFactory(){}ConcreteFactory1::ConcreteFactory1() {}ConcreteFactory1::~ConcreteFactory1() {}AbstractProductA* ConcreteFactory1::CreateProductA() {return new ProductA1(); }AbstractProductB* ConcreteFactory1::CreateProductB() {return new ProductB1(); }ConcreteFactory2::ConcreteFactory2() {}ConcreteFactory2::~ConcreteFactory2() {}AbstractProductA* ConcreteFactory2::CreateProductA() {return new ProductA2(); }AbstractProductB* ConcreteFactory2::CreateProductB() {return new ProductB2();}
//main.cppAbstractFactory* cf1 = new ConcreteFactory1();cf1->CreateProductA();cf1->CreateProductB();AbstractFactory* cf2 = new ConcreteFactory2();cf2->CreateProductA(); cf2->CreateProductB();
AbstractFactory模式和Factory模式的区别是初学（使用）设计模式时候的一个容易引起困惑的地方。实际上，AbstractFactory模式是为创建一组（有多类）相关或依赖的对象提供创建接口，而Factory模式正如我在相应的文档中分析的是为一类对象提供创建接口或延迟对象的创建到子类中实现。并且可以看到，AbstractFactory模式通常都是使用Factory模式实现（ConcreteFactory1）。
Singleton（单例）模式在Singleton模式的结构图中可以看到，我们通过维护一个static的成员变量来记录这个唯一的对象实例。通过提供一个staitc的接口instance来获得这个唯一的实例。
//Singleton.h#ifndef _SINGLETON_H_ #define _SINGLETON_H_class Singleton {public: static Singleton* Instance();protected:Singleton();private: static Singleton* _instance;};#endif //~_SINGLETON_H_//Singleton.cpp#include "Singleton.h"#include <iostream> using namespace std;Singleton* Singleton::_instance = 0;Singleton::Singleton() {cout << "Singleton...." << endl; }Singleton* Singleton::Instance() {if (_instance == 0) {_instance = new Singleton(); }return _instance;}
//main.cppSingleton * sgn = Singleton::Instance();
Singleton模式的实现无须补充解释，需要说明的是，Singleton不可以被实例化，因此我们将其构造函数声明为protected或者直接声明为private。Builder（建造者）模式 0 0
