c++设计模式的实现

源码建Github上项目：https://github.com/liangyuyi/Pattern

Factory设计模式

Factory模式的两个最重要的功能：

1）定义创建对象的接口，封装了对象的创建；

2）使得具体化类的工作延迟到了子类中。

//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.cpp
AbstractFactory* cf1 = new ConcreteFactory1();
	cf1->CreateProductA();
	cf1->CreateProductB();
	AbstractFactory* cf2 = new ConcreteFactory2();
	cf2->CreateProductA(); 
	cf2->CreateProductB();

在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.cpp
Singleton * sgn = Singleton::Instance();

Builder（建造者）模式