设计模式AbstractFactory的C++实现源码

1、抽象工厂类AbstractFactory定义

#ifndef ABSTRACTFACTORY_H
#define ABSTRACTFACTORY_H

#include "AbstractProductA.h"
#include "AbstractProductB.h"

class AbstractFactory
{
public:
 virtual AbstractProductA* createProductA() = 0;
 virtual AbstractProductB* createProductB() = 0;
};

#endif

2、具体工厂类ConcreateFactory1定义

#ifndef CONCREATEFACTORY1_H
#define CONCREATEFACTORY1_H

#include "AbstractFactory.h"

class ConcreateFactory1 : public AbstractFactory
{
public:
 AbstractProductA* createProductA();
 AbstractProductB* createProductB();
};

#endif

 

3、具体工厂类ConcreateFactory1实现

#include <stdio.h>
#include "ConcreateFactory1.h"
#include "ConcreateProductA1.h"
#include "ConcreateProductB1.h"

AbstractProductA* ConcreateFactory1::createProductA()
{
 return new ConcreateProductA1();
}

AbstractProductB* ConcreateFactory1::createProductB()
{
 return new ConcreateProductB1();
}

4、具体工厂类ConcreateFactory2定义

#ifndef CONCREATEFACTORY2_H
#define CONCREATEFACTORY2_H

#include "AbstractFactory.h"

class ConcreateFactory2 : public AbstractFactory
{
public:
 AbstractProductA* createProductA();
 AbstractProductB* createProductB();
};

#endif

 

5、具体工厂类ConcreateFactory2实现

#include <stdio.h>
#include "ConcreateFactory2.h"
#include "ConcreateProductA2.h"
#include "ConcreateProductB2.h"

AbstractProductA* ConcreateFactory2::createProductA()
{
 return new ConcreateProductA2();
}

AbstractProductB* ConcreateFactory2::createProductB()
{
 return new ConcreateProductB2();
}

6、抽象产品AbstractProductA定义

#ifndef ABSTRACTPRODUCTA_H
#define ABSTRACTPRODUCTA_H

#include <stdio.h>

class AbstractProductA
{
public:
 AbstractProductA()
 {
  printf("===AbstractProductA::AbstractProductA()===/n");
 }
 virtual ~AbstractProductA()
 {
  printf("===AbstractProductA::~AbstractProductA()===/n");
 }
 virtual void doneA()=0;
};

#endif

 

7、具体产品ConcreateProductA1定义

#ifndef CONCREATEPRODUCTA1_H
#define CONCREATEPRODUCTA1_H

#include "AbstractProductA.h"

class ConcreateProductA1 : public AbstractProductA
{
public:
 ConcreateProductA1();
 ~ConcreateProductA1();
 void doneA();
};

#endif

 

8、具体产品ConcreateProductA1实现

#include <stdio.h>
#include "ConcreateProductA1.h"

ConcreateProductA1::ConcreateProductA1()
{
 printf("---ConcreateProductA1::ConcreateProductA1()---/n");
}

ConcreateProductA1::~ConcreateProductA1()
{
 printf("---ConcreateProductA1::~ConcreateProductA1()---/n");
}

void ConcreateProductA1::doneA()
{
 printf("---ConcreateProductA1::doneA()---/n");
}

 

9、具体产品ConcreateProductA2定义

#ifndef CONCREATEPRODUCTA2_H
#define CONCREATEPRODUCTA2_H

#include "AbstractProductA.h"

class ConcreateProductA2 : public AbstractProductA
{
public:
 ConcreateProductA2();
 ~ConcreateProductA2();
 void doneA();
};

#endif

 

10、具体产品ConcreateProductA2实现

#include <stdio.h>
#include "ConcreateProductA2.h"

ConcreateProductA2::ConcreateProductA2()
{
 printf("---ConcreateProductA2::ConcreateProductA2()---/n");
}

ConcreateProductA2::~ConcreateProductA2()
{
 printf("---ConcreateProductA2::~ConcreateProductA2()---/n");
}

void ConcreateProductA2::doneA()
{
 printf("---ConcreateProductA2::doneA()---/n");
}

 

11、抽象产品AbstractProductB定义

#ifndef ABSTRACTPRODUCTB_H
#define ABSTRACTPRODUCTB_H

#include <stdio.h>

class AbstractProductB
{
public:
 AbstractProductB()
 {
  printf("===AbstractProductB::AbstractProductB()===/n");
 }
 virtual ~AbstractProductB()
 {
  printf("===AbstractProductB::~AbstractProductB()===/n");
 }
 virtual void doneB() = 0;
};

#endif

 

12、具体产品ConcreateProductB1定义

#ifndef CONCREATEPRODUCTB1_H
#define CONCREATEPRODUCTB1_H

#include "AbstractProductB.h"

class ConcreateProductB1 : public AbstractProductB
{
public:
 ConcreateProductB1();
 ~ConcreateProductB1();
 void doneB();
};

#endif

 

13、具体产品ConcreateProductB1实现

#include <stdio.h>
#include "ConcreateProductB1.h"

ConcreateProductB1::ConcreateProductB1()
{
 printf("---ConcreateProductB1::ConcreateProductB1()---/n");
}

ConcreateProductB1::~ConcreateProductB1()
{
 printf("---ConcreateProductB1::~ConcreateProductB1()---/n");
}

void ConcreateProductB1::doneB()
{
 printf("---ConcreateProductB1::doneB()---/n");
}

 

14、具体产品ConcreateProductB2定义

#ifndef CONCREATEPRODUCTB2_H
#define CONCREATEPRODUCTB2_H

#include "AbstractProductB.h"

class ConcreateProductB2 : public AbstractProductB
{
public:
 ConcreateProductB2();
 ~ConcreateProductB2();
 void doneB();
};

#endif

 

15、具体产品ConcreateProductB2实现

#include <stdio.h>
#include "ConcreateProductB2.h"

ConcreateProductB2::ConcreateProductB2()
{
 printf("---ConcreateProductB2::ConcreateProductB2()---/n");
}

ConcreateProductB2::~ConcreateProductB2()
{
 printf("---ConcreateProductB2::~ConcreateProductB2()---/n");
}

void ConcreateProductB2::doneB()
{
 printf("---ConcreateProductB2::doneB()---/n");
}

 

16、客户使用类Client实现

#include <string.h>
#include <stdio.h>
#include "AbstractFactory.h"
#include "AbstractProductA.h"
#include "AbstractProductB.h"
#include "ConcreateFactory1.h"
#include "ConcreateFactory2.h"

#define CONFAC1 "ConcreateFactory1"
#define CONFAC2 "ConcreateFactory2"

AbstractFactory* createFactory(char* str)
{
 if(str == NULL)
 {
  return NULL;
 }

 if(strcmp(str,CONFAC1) == 0)
 {
  return new ConcreateFactory1();
 }

 if(strcmp(str,CONFAC2) == 0)
 {
  return new ConcreateFactory2();
 }

 return NULL;
}

int main()
{
 AbstractFactory* af = createFactory(CONFAC1);
 AbstractProductA* apa = af->createProductA();
 apa->doneA();
 AbstractProductB* apb = af->createProductB();
 apb->doneB();
 delete apa;
 delete apb;
 delete af;
 af = createFactory(CONFAC2);
 apa = af->createProductA();
 apa->doneA();
 apb = af->createProductB();
 apb->doneB();
 delete apa;
 delete apb;
 delete af;

 return 0;
}