抽象工厂（Abstract Factory）模式

 抽象工厂（Abstract Factory）模式

 

//Factory.h
#ifndef DEF_FACTORY_H_
#define DEF_FACTORY_H_
/
/*

抽象工厂（Abstract Factory）角色：担任这个角色的是工厂方法模式的核心，它是与应用系统商业逻辑无关的。

具体工厂（Concrete Factory）角色：这个角色直接在客户端的调用下创建产品的实例。这个角色含有选择合适的产品对象的逻辑，而这个逻辑是与应用系统的商业逻辑紧密相关的。

抽象产品（Abstract Product）角色：担任这个角色的类是工厂方法模式所创建的对象的父类，或它们共同拥有的接口。

具体产品（Concrete Product）角色：抽象工厂模式所创建的任何产品对象都是某一个具体产品类的实例。这是客户端最终需要的东西，其内部一定充满了应用系统的商业逻辑。

 

*/
/

class Text;
class Button;
//抽象工厂
class AbstractFactory
{
public:
 virtual Text*   CreateText() = 0;
 virtual Button* CreateButton() = 0;
 
};

//具体工厂
class UnixFactory : public AbstractFactory
{
public:
 Text*   CreateText();
 Button* CreateButton();
};

//具体工厂
class WindowsFactory : public AbstractFactory
{
public:
 Text*   CreateText();
 Button* CreateButton();
};
#endif

 

 

///

#include "stdafx.h"
#include "Factory.h"
#include <iostream>
//Factory.cpp

#include "Button.h"
#include "Text.h"

using namespace std;

 

Button* WindowsFactory::CreateButton()
{
 cout<<"WindowsFactory::CreateButton"<<endl;
 return new WindowsButton;
}

Text* WindowsFactory::CreateText()
{
 cout<<"WindowsFactory::CreateText"<<endl;
 return  new WindowsText;
}

Button* UnixFactory::CreateButton()
{
 cout<<"UnixFactory::CreateButton"<<endl;
 return  new UnixButton;
}

Text* UnixFactory::CreateText()
{
 cout<<"UnixFactory::CreateText"<<endl;
 return  new UnixText;
}

 

///

 

//Button.h

#ifndef DEF_BUTTON_H_
#define DEF_BUTTON_H_
/
/*

抽象产品（Abstract Product）角色：担任这个角色的类是工厂方法模式所创建的对象的父类，或它们共同拥有的接口。

具体产品（Concrete Product）角色：抽象工厂模式所创建的任何产品对象都是某一个具体产品类的实例。这是客户端最终需要的东西，其内部一定充满了应用系统的商业逻辑。

*/
/

//抽象产品
class Button
{
public:
 virtual void Create() = 0;
};

//具体产品
class UnixButton : public Button
{
public:
 virtual void Create();
};

//具体产品
class WindowsButton : public Button
{
public:
 virtual void Create();
};

#endif

 

 

 

 

//button.cpp
#include "stdafx.h"
#include "Button.h"
#include <iostream>

using namespace std;

void UnixButton::Create()
{
 cout<<"UnixButton::Create"<<endl;
}

 

void WindowsButton::Create()
{
 cout<<"WindowsButton::Create"<<endl;
}

 

 

//Enviroment.h
#ifndef DEF_ENVIROMENT_H_
#define DEF_ENVIROMENT_H_
#include "Factory.h"

enum SystemEnviroment
{
 enum_Unix_Enviroment,
 enum_Windows_Enviroment
};

class Enviroment
{
public:
 Enviroment();
 void Run(SystemEnviroment aoEnviroment);
private:
 void RunTest(AbstractFactory* apFactory);
};
#endif

 

 

 

 

#include "stdafx.h"
#include "Enviroment.h"
#include "Button.h"
#include "Text.h"

Enviroment::Enviroment()
{ 
}

void Enviroment::Run(SystemEnviroment aoEnviroment)
{
 AbstractFactory* lpFactory = NULL;

 switch(aoEnviroment)
 {
 case enum_Unix_Enviroment:
  {
   lpFactory = new WindowsFactory;
   RunTest(lpFactory);
  }
  break;
 case enum_Windows_Enviroment:
  {
   lpFactory = new UnixFactory;
   RunTest(lpFactory);
  }
  break;
 }

 delete lpFactory;
 lpFactory = NULL;
 

}

void Enviroment::RunTest(AbstractFactory* apFactory)
{
 Button* lpButton = NULL;
 Text*   lpText = NULL;

 lpButton = apFactory->CreateButton();
 lpButton->Create();

 lpText = apFactory->CreateText();
 lpText->Creat();

 delete lpButton;
 lpButton  = NULL;

 delete lpText;
 lpText = NULL;
}

 

//Text.h
#ifndef DEF_TEXT_H_
#define DEF_TEXT_H_
/
/*
抽象产品（Abstract Product）角色：担任这个角色的类是工厂方法模式所创建的对象的父类，或它们共同拥有的接口。

具体产品（Concrete Product）角色：抽象工厂模式所创建的任何产品对象都是某一个具体产品类的实例。这是客户端最终需要的东西，其内部一定充满了应用系统的商业逻辑。

*/
/

//抽象产品
class Text
{
public:
 virtual void Creat() = 0;
};

//具体产品
class UnixText : public Text
{
public:
 virtual void Creat();
};

//具体产品
class WindowsText : public Text
{
public:
 virtual void Creat();
};
#endif

 

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

void UnixText::Creat()
{
 cout<<"UnixText::Creat()"<<endl;
}

void WindowsText::Creat()
{
 cout<<"WindowsText::Creat()"<<endl;
}

 

 

#include "stdafx.h"
#include "Enviroment.h"

 

 

int _tmain(int argc, _TCHAR* argv[])
{

 Enviroment loTestEnviroment;
 loTestEnviroment.Run(enum_Unix_Enviroment);
 loTestEnviroment.Run(enum_Windows_Enviroment);
 return 0;
}