C++设计模式 -> 创建型 -> 抽象工厂（Abstract Factory）

抽象工厂模式（Abstract Factory）

——————— 抽象工厂 | 具体工厂 ————————–

——————— 抽象产品 | 具体产品 ————————–

逻辑

头文件

#ifndef FACTORY_H
#define FACTORY_H

#include "Base_Product.h"

/* 抽象工厂 */
class Base_Factory
{
public:
enum FACTORY_TYPE
{
BENZ_FACTORY,  /* 奔驰工厂 */
BMW_FACTORY,   /* 宝马工厂 */
};
/* 实例化具体工厂 */
static bool Base_Factory::Create_Factory(Base_Factory*& base_factory_index,
FACTORY_TYPE   factory);
/* 生产汽车 */
virtual Base_Car* Create_Car() = 0;
/* 生产自行车 */
virtual Base_Bike* Create_Bike() = 0;

protected:

private:

};

#endif // FACTORY_H

#ifndef CONCRETE_FACTORY_H
#define CONCRETE_FACTORY_H
#include "Base_Factory.h"
#include "concrete_product.h"

/* 奔驰工厂 */
class Benz_Factory : public Base_Factory
{
public:
Base_Car* Create_Car(){
return new Benz_Car;
}

Base_Bike* Create_Bike(){
return new Benz_Bike;
}
protected:
private:
};

/* 宝马工厂 */
class Bmw_Factory : public Base_Factory
{
public:
Base_Car* Create_Car(){
return new Bmw_Car;
}

Base_Bike* Create_Bike(){
return new Bmw_Bike;
}
protected:
private:
};

#endif // CONCRETE_FACTORY_H

#ifndef Produce_H
#define Produce_H

#include <string>

using namespace std;

// 抽象汽车类
class Base_Car
{
public:
virtual string Produce_Car() = 0;  // 生产汽车

protected:

private:
};

// 抽象自行车类
class Base_Bike
{

public:
virtual string Produce_Bike() = 0;  // 生产自行车

protected:

private:

};

#endif // Produce_H

#ifndef CONCRETE_Produce_H
#define CONCRETE_Produce_H
#include "Base_Product.h"
/********** 汽车 **********/
// 奔驰
class Benz_Car : public Base_Car
{
public:
string Produce_Car(){
return "  Benz Car   ";
}
protected:
private:
};

// 宝马
class Bmw_Car : public Base_Car
{
public:
string Produce_Car(){
return "   Bmw Car  ";
}
protected:
private:
};

/********** 自行车 **********/
// 奔驰
class Benz_Bike : public Base_Bike
{
public:
string Produce_Bike(){
return "  Benz Bike  ";
}
protected:
private:
};

// 宝马
class Bmw_Bike : public Base_Bike
{
public:
string Produce_Bike(){
return "  Bmw Bike  ";
}
protected:
private:
};

#endif // CONCRETE_Produce_H

源文件

#include "Base_Factory.h"
#include "concrete_factory.h"

/* 实例具体工厂 */
bool Base_Factory::Create_Factory(Base_Factory*& base_factory_index, FACTORY_TYPE factory)
{
switch (factory)
{
// 奔驰工厂
case FACTORY_TYPE::BENZ_FACTORY:
base_factory_index = new Benz_Factory;
break;

// 宝马工厂
case FACTORY_TYPE::BMW_FACTORY:
base_factory_index = new Bmw_Factory;
break;

default:
return false;

}
return true;
}

#include "Base_Factory.h"
#include "Base_Product.h"
#include <iostream>

using namespace std;

#ifndef SAFE_DELETE
#define SAFE_DELETE(index) { if(index){delete(index); (index)=NULL;} }
#endif

int main()
{
Base_Factory* base_factory_index = NULL;
Base_Car* car_index = NULL;
Base_Bike* bike_index = NULL;

// 奔驰
Base_Factory::Create_Factory(base_factory_index, Base_Factory::FACTORY_TYPE::BENZ_FACTORY);
car_index = base_factory_index->Create_Car();
bike_index = base_factory_index->Create_Bike();

cout << car_index->Produce_Car() << endl;
cout << bike_index->Produce_Bike() << endl;

SAFE_DELETE(car_index);
SAFE_DELETE(bike_index);
SAFE_DELETE(base_factory_index);

// 宝马
Base_Factory::Create_Factory(base_factory_index, Base_Factory::FACTORY_TYPE::BMW_FACTORY);
car_index = base_factory_index->Create_Car();
bike_index = base_factory_index->Create_Bike();

cout << car_index->Produce_Car() << endl;
cout << bike_index->Produce_Bike() << endl;

SAFE_DELETE(car_index);
SAFE_DELETE(bike_index);
SAFE_DELETE(base_factory_index);

getchar();

return 0;
}