工厂方法模式

1、场景举例

还是简单工厂模式说的那家买鞋店，为了适应市场需求，对于鞋子类型扩展了很多种，不仅有布鞋、皮鞋，还生产拖鞋、凉鞋、高跟鞋、足球鞋。。。，如果依旧使用简单工厂模式，那么每增加一个鞋子的种类，就需要对工厂进行一次修改，由于对已经存在的函数进行了修改，那么以前进行过的测试，都将是无效的，所有的测试，都将需要重新进行，所有的代码都需要进行重新覆盖。这样下来测试成本将会大幅提高。

2、主要应用场景

1、逻辑中会经常使用到该类对象（需要经常进行new、malloc操作）
2、逻辑后续会有一定规模，最好这个时候就将对象的创建和使用分离
3、后续会小范围扩展产品类型
4、程序规模比较大，不希望每次增加产品后都对之前逻辑重新测试

3、类图

4、用C语言实现工厂方法模式

4.1、角色定义

1、设计不同对象结构
2、设计不同对象工厂函数
3、定义抽象工厂结构
4、设计创建工厂函数

4.2、案例描述

使用工厂方法模式实现，生产橘子和苹果两种水果

4.3、案例实现

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

enum {GRAPE,APPLE};

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

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

void print_apple()
{
	printf("apple!\n");
}

void print_grape()
{
	printf("grape!\n");
}
Apple* sell_apple()
{
	Apple* pApple = (Apple*)malloc(sizeof(Apple));
	assert(NULL != pApple);

	pApple->print_apple = print_apple;
	return pApple;
}

Grape* sell_grape()
{
	Grape* pGrape = (Grape*)malloc(sizeof(Grape));
	assert(NULL != pGrape);

	pGrape->print_grape = print_grape;
	return pGrape;
}

typedef struct _FruitShop
{
	void* (*sell_fruit)();
}FruitShop;

FruitShop* create_fruit_shop(int fruit)
{
	FruitShop* pFruitShop = (FruitShop*)malloc(sizeof(FruitShop));
	assert(NULL != pFruitShop);

	if (GRAPE == fruit)
	{
		pFruitShop->sell_fruit = (void *(*)())sell_apple;
	}
	else if(APPLE == fruit)
	{
		pFruitShop->sell_fruit = (void *(*)())sell_grape;
	}
	else
	{
		return NULL;
	}

	return pFruitShop;
}


int main()
{
	FruitShop* apple = NULL;
	Apple* a = NULL;
	apple = create_fruit_shop(APPLE);
	a = (Apple *)apple->sell_fruit();

	a->print_apple();
	
	FruitShop* grape = NULL;
	Grape* g = NULL;
	grape = create_fruit_shop(GRAPE);
	g = (Grape*)grape->sell_fruit();

	g->print_grape();

	if(g != NULL){
		delete g;
	}
	if(grape != NULL){
		delete grape;
	}
	if(a != NULL){
		delete a;
	}
	if(apple != NULL){
		delete apple;
	}

	return 0;

}

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

5.1、角色定义

1、设计产品接口
2、设计产品A类，继承产品接口
3、设计产品B类，继承产品接口
4、设计工厂接口
5、设计工厂A，继承工厂接口
6、设计工厂B，继承工厂接口

5.2、案例描述

使用工厂方法模式，简单制作两个工厂，分别生产一个各自产品

5.3、案例实现

#include <iostream>
using namespace std;

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

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

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

class Factory
{
public:
    virtual Product *CreateProduct() = 0;
};

class FactoryA : public Factory
{
public:
    Product *CreateProduct()
    {
        return new ProductA ();
    }
};

class FactoryB : public Factory
{
public:
    Product *CreateProduct()
    {
        return new ProductB ();
    }
};

int main(int argc , char *argv [])
{
    Factory *factoryA = new FactoryA ();
    Product *productA = factoryA->CreateProduct();
    productA->Show();

    Factory *factoryB = new FactoryB ();
    Product *productB = factoryB->CreateProduct();
    productB->Show();

    if (factoryA != NULL)
    {
        delete factoryA;
        factoryA = NULL;
    }

    if (productA != NULL)
    {
        delete productA;
        productA = NULL;
    }

    if (factoryB != NULL)
    {
        delete factoryB;
        factoryB = NULL;
    }

    if (productB != NULL)
    {
        delete productB;
        productB = NULL;
    }
    return 0;
}

6、缺点

1、后续产品种类特别多的时候，需要建立很多工厂，导致程序熵值太大
2、对于有依赖关系的对象，如果在一个工厂中实现，可以省去很多重复逻辑