用工厂方法（Factory Method）和 单例模式（Singleton）实现抽象工厂（Abstract Factory）

<pre name="code" class="cpp">//ProductA.h

#ifndef PRODUCTA_H_
#define PRODUCTA_H_

class AbstractProductA
{
public:
	virtual ~AbstractProductA();
	virtual void OperationProductA() = 0;
};


class ConcreteProductA1:public AbstractProductA
{
public:
	ConcreteProductA1();
	virtual ~ConcreteProductA1();
	virtual void OperationProductA();
};


class ConcreteProductA2:public AbstractProductA
{
public:
	ConcreteProductA2();
	virtual ~ConcreteProductA2();
	virtual void OperationProductA();
};




#endif

//ProductA.cpp

#include "ProductA.h"
#include <iostream>
using namespace std;

//class AbstractProductA
AbstractProductA::~AbstractProductA()
{

	cout<<"AbstractProductA::~AbstractProductA()"<<endl;
}


//class ConcreteProductA1
ConcreteProductA1::ConcreteProductA1()
{
	
	cout<<"ConcreteProductA1::ConcreteProductA1()"<<endl;
}

ConcreteProductA1::~ConcreteProductA1()
{

	cout<<"ConcreteProductA1::~ConcreteProductA1()"<<endl;
}

void ConcreteProductA1::OperationProductA()
{

	cout<<"void ConcreteProductA1::OperationProductA()"<<endl;
}


//class ConcreteProductA2
ConcreteProductA2::ConcreteProductA2()
{
	
	cout<<"ConcreteProductA2::ConcreteProductA2()"<<endl;
}

ConcreteProductA2::~ConcreteProductA2()
{

	cout<<"ConcreteProductA2::~ConcreteProductA2()"<<endl;
}

void ConcreteProductA2::OperationProductA()
{

	cout<<"void ConcreteProductA2::OperationProductA()"<<endl;
}

//ProductB.h
#ifndef PRODUCTB_H_
#define PRODUCTB_H_

class AbstractProductB
{
public:
	virtual ~AbstractProductB();
	virtual void OperationProductB() = 0;
};


class ConcreteProductB1:public AbstractProductB
{
public:
	ConcreteProductB1();
	virtual ~ConcreteProductB1();
	virtual void OperationProductB();
};


class ConcreteProductB2:public AbstractProductB
{
public:
	ConcreteProductB2();
	virtual ~ConcreteProductB2();
	virtual void OperationProductB();
};


#endif

//ProductB.cpp

#include "ProductB.h"
#include <iostream>
using namespace std;

//class AbstractProductB
AbstractProductB::~AbstractProductB()
{

	cout<<"AbstractProductB::~AbstractProductB()"<<endl;
}


//class ConcreteProductB1
ConcreteProductB1::ConcreteProductB1()
{
	
	cout<<"ConcreteProductB1::ConcreteProductB1()"<<endl;
}

ConcreteProductB1::~ConcreteProductB1()
{

	cout<<"ConcreteProductB1::~ConcreteProductB1()"<<endl;
}

void ConcreteProductB1::OperationProductB()
{

	cout<<"void ConcreteProductB1::OperationProductB()"<<endl;
}


//class ConcreteProductB2
ConcreteProductB2::ConcreteProductB2()
{
	
	cout<<"ConcreteProductB2::ConcreteProductB2()"<<endl;
}

ConcreteProductB2::~ConcreteProductB2()
{

	cout<<"ConcreteProductB2::~ConcreteProductB2()"<<endl;
}

void ConcreteProductB2::OperationProductB()
{

	cout<<"void ConcreteProductB2::OperationProductB()"<<endl;
}

//Factory.h
#ifndef FACTORY_H_
#define FACTORY_H_

class AbstractProductA;
class AbstractProductB;

class AbstractFactory
{
public:

	virtual ~AbstractFactory();

	virtual AbstractProductA* CreateProductA() = 0;

	virtual AbstractProductB* CreateProductB() = 0;

};

#endif

//Factory.cpp

#include "Factory.h"

#include <iostream>
AbstractFactory::~AbstractFactory()
{

	std:: cout<<"AbstractFactory::~AbstractFactory（）"<<std::endl;
}

//Factory1.h

#ifndef FACTORY1_H_
#define FACTORY1_H_

#include "Factory.h"

class ConcreteFactory1:public AbstractFactory
{
public:

	static ConcreteFactory1* GetSingleFactory1();

	virtual ~ConcreteFactory1();

	virtual AbstractProductA* CreateProductA();

	virtual AbstractProductB* CreateProductB();

protected:
	ConcreteFactory1();

private:
	static ConcreteFactory1* _instance;
	
};


#endif

//Factory1.cpp

#include <iostream>
using namespace std;

#include "Factory1.h"

#include "ProductA.h"
#include "ProductB.h"

class AbstractProductA;
class AbstractProductB;


ConcreteFactory1::ConcreteFactory1()
{
	cout<<"ConcreteFactory1::ConcreteFactory()1"<<endl;
}


ConcreteFactory1::~ConcreteFactory1()
{

	cout<<"ConcreteFactory1::~ConcreteFactory()1"<<endl;
}


AbstractProductA* ConcreteFactory1::CreateProductA()
{
	cout<<"AbstractProductA* ConcreteFactory1::CreateProductA()"<<endl;
	return new ConcreteProductA1();
}

AbstractProductB* ConcreteFactory1::CreateProductB()
{

	cout<<"AbstractProductB* ConcreteFactory1::CreateProductB()"<<endl;
	return new ConcreteProductB1();
}


ConcreteFactory1* ConcreteFactory1::_instance = NULL;

ConcreteFactory1* ConcreteFactory1::GetSingleFactory1()
{

	cout<<"ConcreteFactory1* ConcreteFactory1::GetSingleFactory1()"<<endl;
	if(_instance == NULL)
	{

		_instance = new ConcreteFactory1();
	}

	return _instance;
}

//Factory2.h

#ifndef FACTORY2_H_
#define FACTORY2_H_

#include "Factory.h"

class ConcreteFactory2:public AbstractFactory
{
public:


	virtual ~ConcreteFactory2();

	virtual AbstractProductA* CreateProductA();

	virtual AbstractProductB* CreateProductB();

	static ConcreteFactory2* GetSingleFactory2();

protected:
	ConcreteFactory2();

private:
	static ConcreteFactory2* _instance;
	
};


#endif

//Factory.cpp

#include "Factory2.h"
#include "ProductA.h"
#include "ProductB.h"
 
#include <iostream>
using namespace std;


ConcreteFactory2::ConcreteFactory2()
{

	cout<<"ConcreteFactory2::ConcreteFactory2()"<<endl;
}

ConcreteFactory2::~ConcreteFactory2()
{

	cout<<"ConcreteFactory2::~ConcreteFactory2()"<<endl;
}


AbstractProductA* ConcreteFactory2::CreateProductA()
{
	cout<<"AbstractProductA* ConcreteFactory2::CreateProductA()"<<endl;
	return new ConcreteProductA2();
}


AbstractProductB* ConcreteFactory2::CreateProductB()
{
	cout<<"AbstractProductB* ConcreteFactory2::CreateProductB()"<<endl;
	return new ConcreteProductB2();
}


ConcreteFactory2* ConcreteFactory2::_instance = NULL;

ConcreteFactory2* ConcreteFactory2::GetSingleFactory2()
{

	cout<<"ConcreteFactory2* ConcreteFactory2::GetSingleFactory2()"<<endl;

	if(_instance == NULL)
	{

		_instance = new ConcreteFactory2();
	}

	return _instance;

}

//Client.cpp

#include "Factory.h"
#include "ProductA.h"
#include "ProductB.h"
#include "Factory1.h"
#include "Factory2.h"

#include <iostream>
using namespace std;


void main()
{
	AbstractFactory *pFactory1 =  ConcreteFactory1::GetSingleFactory1 ();

	//Test Singleton 
	AbstractFactory *pFactory11 =  ConcreteFactory1::GetSingleFactory1 ();

	AbstractProductA *pProductA1 = pFactory1->CreateProductA();

	pProductA1->OperationProductA();

	delete pFactory1;
	delete pProductA1;


	cout<<endl<<endl<<endl;


	AbstractFactory *pFactory2 = ConcreteFactory2::GetSingleFactory2();

	AbstractProductB *pProductB2 = pFactory2->CreateProductB();

	pProductB2->OperationProductB();

	delete pFactory2;
	delete pProductB2;
}