抽象工厂（AbstractFactory）

//#include "Product.h"
class AbstractProductA;
class AbstractProductB;
class AbstractFactory
{
public:
//AbstractFactory();
virtual ~AbstractFactory();
virtual AbstractProductA*  CreateProductA()= 0;
virtual AbstractProductB*  CreateProductB()= 0;
protected:

private:

};
class ConcreateFactory1:public AbstractFactory
{
public:
ConcreateFactory1();
~ConcreateFactory1();
AbstractProductA* CreateProductA();
AbstractProductB* CreateProductB();
protected:

private:
};
class ConcreateFactory2:public AbstractFactory
{
public:
ConcreateFactory2();
~ConcreateFactory2();
AbstractProductA* CreateProductA();
AbstractProductB* CreateProductB();
protected:

private:
};

#include "stdafx.h"
#include "AbstractFactory.h"

//AbstractFactory::AbstractFactory()
//{
//
//}
AbstractFactory::~AbstractFactory()
{

}
ConcreateFactory1::ConcreateFactory1()
{

}
ConcreateFactory1::~ConcreateFactory1()
{

}
AbstractProductA* ConcreateFactory1::CreateProductA()
{
return new ProductA1();
}
AbstractProductB* ConcreateFactory1::CreateProductB()
{
return new ProductB1();
}
ConcreateFactory2::ConcreateFactory2()
{

}
ConcreateFactory2::~ConcreateFactory2()
{

}
AbstractProductA* ConcreateFactory2::CreateProductA()
{
return new ProductA2();
}
AbstractProductB* ConcreateFactory2::CreateProductB()
{
return new ProductB2();
}

#ifndef _PRODUCT_H
#define _PRODUCT_H
class AbstractProductA
{
public:
virtual ~AbstractProductA();
protected:
AbstractProductA();
private:
};
class AbstractProductB
{
public:
virtual ~AbstractProductB();
protected:
AbstractProductB();
private:
};

class ProductA1 : public AbstractProductA
{
public:
ProductA1();
~ProductA1();
protected:

private:
};
class ProductA2 : public AbstractProductA
{
public:
ProductA2();
~ProductA2();
protected:

private:
};

class ProductB1 : public AbstractProductB
{
public:
ProductB1();
~ProductB1();
protected:

private:
};
class ProductB2 : public AbstractProductB
{
public:
ProductB2();
~ProductB2();
protected:

private:
};

#endif

#include "stdafx.h"
#include "Product.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()
{

}

// AbstactFactory.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "Product.h"
#include "AbstractFactory.h"
#include <iostream>
#include "windows.h"
using namespace std;

int _tmain(int argc, _TCHAR* argv[])
{
AbstractFactory* cf1 = new ConcreateFactory1();
Sleep(5000);
cf1->CreateProductA();
Sleep(5000);
cf1->CreateProductB();
Sleep(5000);
AbstractFactory* cf2 = new ConcreateFactory2();
Sleep(5000);
cf2->CreateProductA();
Sleep(5000);
cf2->CreateProductB();
Sleep(5000);
while(true);

return 0;
}