抽象工厂模式

1、场景举例

还是那个买鞋厂，在大规模扩展了鞋子种类之后，发现单独买鞋带，鞋垫也有一定市场，这个时候如果使用工厂方法模式，那就需要针对鞋带和鞋垫再单独编写自己的工厂函数，但是制造鞋垫和鞋带是制造鞋子过程中的一部分，如果单独针对这两部分单独再创建工厂，代价未免过大。这个时候抽象工厂模式可以完美解决这类问题，仅增加了一条生产鞋带和鞋垫的流水线即可。

2、主要应用场景

1、对象之间存在联系，两个对象同一个工厂生产，降低程序复杂度，减少不必要的重复逻辑
2、对象数量比较大，维护多个工厂程序复杂度太高。

3、类图

4、用C语言实现抽象工厂模式

4.1、角色定义

1、定义一组对象创建函数接口
2、编写对象创建函数具体实现
3、定义工厂接口结构
4、实现工厂接口函数的具体函数
5、实现创建工厂组函数

4.2、案例描述

水果店有白苹果、红苹果、白橘子、红橘子。使用抽象工厂模式实现不同颜色的苹果和橘子的组合工厂。

4.3、案例实现

/*用C语言实现抽象工厂模式*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>

enum {WHITE,RED};

typedef struct _Apple {
	void (*print_apple)(void);
}Apple;

typedef struct _Grape {
	void (*print_grape)(void);
}Grape;

void print_white_apple(void) 
{
	printf("I'am a white apple!\n");
	return;
}

void print_red_apple(void)
{
	printf("I'am a read apple!\n");
	return;
}
void print_white_grape(void)
{
	printf("I'am a white grape!\n");
	return;
}
void print_red_grape(void)
{
	printf("I'am a red grape!\n");
	return;
}

typedef struct _FruitShop {
	Apple * (*sell_apple)(void);
	Grape * (*sell_grape)(void);
}FruitShop;

Apple* sell_white_apple(void)
{
	Apple* tmp_apple = (Apple*)malloc(sizeof(Apple));
	assert(NULL != tmp_apple);

	tmp_apple->print_apple = print_white_apple;

	return tmp_apple;
}

Apple* sell_red_apple(void)
{
	Apple* tmp_apple = (Apple*)malloc(sizeof(Apple));
	assert(NULL != tmp_apple);

	tmp_apple->print_apple = print_red_apple;

	return tmp_apple;
}

Grape* sell_white_grape(void)
{
	Grape* tmp_grape = (Grape*)malloc(sizeof(Grape));
	assert(tmp_grape != NULL);

	tmp_grape->print_grape = print_white_grape;
	return tmp_grape;
}
Grape* sell_red_grape(void)
{
	Grape* tmp_grape = (Grape*)malloc(sizeof(Grape));
	assert(tmp_grape);

	tmp_grape->print_grape = print_red_grape;

	return tmp_grape;
}

FruitShop* create_fruit_shop(int color)
{
	FruitShop* fruitshop = (FruitShop*)malloc(sizeof(FruitShop));
	assert(fruitshop != NULL);

	if (color == WHITE) {
		fruitshop->sell_apple = sell_white_apple;
		fruitshop->sell_grape = sell_white_grape;
	}
	else if (color == RED) {
		fruitshop->sell_apple = sell_red_apple;
		fruitshop->sell_grape = sell_red_grape;
	}

	return fruitshop;
}

int main()
{
	FruitShop* fruitshop = create_fruit_shop(WHITE);

	Apple *ap = fruitshop->sell_apple();
	Grape *gp = fruitshop->sell_grape();

	ap->print_apple();
	gp->print_grape();

	if (ap != NULL) {
		free(ap);
	}
	if (gp != NULL) {
		free(gp);
	}
	if (fruitshop != NULL) {
		free(fruitshop);
	}

	return 0;
}

5、使用C++实现抽象工厂模式

5.1、角色定义

1、定义一组产品接口
2、定义具体产品，一个接口对应多个子产品
3、定义工厂接口
4、根据工厂接口定义子工厂

5.2、案例描述

现存在两个类产品，产品A和产品B，同时产品A下又有产品A1，产品B下又有产品B1。使用抽象工厂模式实现对应A、B两种产品的不同组合的工厂

5.3、案例实现

#include <iostream>
using namespace std;

class ProductA {
public:
	virtual void Show() = 0;
};

class  ProductB {
public:
	virtual void Show() = 0;
};

class ProductA1 :public ProductA {
public:
	void Show() 
	{
		cout << "I'm a ProductA1" << endl;
	}
};

class ProductA2 :public ProductA {
public:
	void Show()
	{
		cout << "I'm a ProductA2" << endl;
	}
};

class ProductB1 :public ProductB {
public:
	void Show()
	{
		cout << "I'm a ProductB1" << endl;
	}
};

class ProductB2 :public ProductB {
public:
	void Show()
	{
		cout << "T'm a ProductB2" << endl;
	}
};

class Factory 
{
public:
	virtual ProductA* CreateProductA() = 0;
	virtual ProductB* CreateProductB() = 0;
};

class Factory1 :public Factory 
{
public:
	ProductB* CreateProductB()
	{
		return new ProductB1();
	}

	ProductA* CreateProductA() 
	{
		return new ProductA1();
	}
};

class Factory2 :public Factory 
{
public:
	ProductB* CreateProductB() 
	{
		return new ProductB2();
	}

	ProductA* CreateProductA()
	{
		return new ProductA2();
	}

};

int main()
{
	Factory* factory1 = new Factory1();
	ProductA* productA1 = factory1->CreateProductA();
	ProductB* productB1 = factory1->CreateProductB();

	productA1->Show();
	productB1->Show();

	Factory* factory2 = new Factory2();
	ProductA* productA2 = factory2->CreateProductA();
	ProductB* productB2 = factory2->CreateProductB();

	productA2->Show();
	productB2->Show();

	if (productA2 != NULL) {
		delete productA2;
	}
	if (productB2 != NULL) {
		delete productB2;
	}
	if (productA1 != NULL) {
		delete productA1;
	}
	if (productB1 != NULL) {
		delete productB1;
	}
	if (factory1 != NULL) {
		delete factory1;
	}
	if (factory2 != NULL) {
		delete factory2;
	}

}