【设计模式：abstract factory patttern】

#include <iostream>
#include <sstream>
#include <cstdio>
class AbstractProductA{
public:
	using Version = unsigned int;
public:
	virtual ~AbstractProductA( void ) {}
	Version ProductVersion;
};
class ConcreteProductA_Vers1 : public AbstractProductA{
public:
	ConcreteProductA_Vers1( void ) {
		ProductVersion = 1;
	}
};
class ConcreteProductA_Vers2 : public AbstractProductA{
public:
	ConcreteProductA_Vers2( void ) {
		ProductVersion = 2;
	}
};

class AbstractProductB{
public:
	using Version = unsigned int;
public:
	virtual ~AbstractProductB( void ) {}
	Version ProductVersion;
};
class ConcreteProductB_Vers1 : public AbstractProductB{
public:
	ConcreteProductB_Vers1( void ) {
		ProductVersion = 1;
	}
};
class ConcreteProductB_Vers2 : public AbstractProductB{
public:
	ConcreteProductB_Vers2( void ) {
		ProductVersion = 2;
	}
};

class AbstractFactory{
public:
	virtual ~AbstractFactory( void ) {}
	virtual AbstractProductA *CreateConcreteProductA( void ) const = 0;
	virtual AbstractProductB *CreateConcreteProductB( void ) const = 0;
};
class ConcreteFactory_Vers1 : public AbstractFactory{
public:
	virtual AbstractProductA *CreateConcreteProductA( void ) const override{
		return new ConcreteProductA_Vers1;
	}
	virtual AbstractProductB *CreateConcreteProductB( void ) const override{
		return new ConcreteProductB_Vers1;
	}
};
class ConcreteFactory_Vers2 : public AbstractFactory{
public:
	virtual AbstractProductA *CreateConcreteProductA( void ) const override{
		return new ConcreteProductA_Vers2;
	}
	virtual AbstractProductB *CreateConcreteProductB( void ) const override{
		return new ConcreteProductB_Vers2;
	}
};

class Client{
protected:
	AbstractFactory *PolymorphicFactoryPointer;
private:
	AbstractProductA *PolymorphicProductAPointer;
	AbstractProductB *PolymorphicProductBPointer;
public:
	Client( const AbstractFactory *GivenFactoryPointer )
		:PolymorphicFactoryPointer(const_cast< AbstractFactory *>(GivenFactoryPointer)){
			PolymorphicProductAPointer =
				PolymorphicFactoryPointer->CreateConcreteProductA();
			PolymorphicProductBPointer =
				PolymorphicFactoryPointer->CreateConcreteProductB();
		}
	~Client( void ){
		if( PolymorphicProductAPointer )
			delete PolymorphicProductAPointer;
		if( PolymorphicProductBPointer )
			delete PolymorphicProductBPointer;
		PolymorphicProductAPointer = nullptr;
		PolymorphicProductBPointer = nullptr;
	}
	void ABussiness( void ){
		std::ostringstream oss;
		char _MsgBuf[ 64 ];
		sprintf(_MsgBuf,
				"Client owns a Product A vers %u\n"
				"\ta Product B vers%u\n",
				PolymorphicProductAPointer->ProductVersion,
				PolymorphicProductBPointer->ProductVersion );
		oss << _MsgBuf;
		std::cout << oss.str() << std::flush;
	}
};

int main( void ){
	ConcreteFactory_Vers1 concrFV_1;
	ConcreteFactory_Vers2 concrFV_2;
	Client client_1( &concrFV_1 );
	Client client_2( &concrFV_2 );
	
	client_1.ABussiness();
	puts("--------------");
	client_2.ABussiness();

	return 0;
}