C++设计模式---工厂模式

目录

设计模式概念

工厂模式分类

简单工厂

工厂方法

抽象工厂

---

设计模式概念

简单来说，设计模式就是在解决某一类问题时，有既定的优秀的代码框架可以用，优点如下：

1. 代码易于维护；
2. 能够做到软件设计的开-闭原则（对修改关闭，对扩展开放）；
3. 合理的设计模式，能够做到软件设计的高内聚，低耦合。

工厂模式分类

1. 简单工厂       Simple Factory
2. 工厂方法       Factory Method
3. 抽象工厂       Abstract Factory

针对以上三种模式，先给出结论如下：

• 简单工厂不符合软件设计的开-闭原则，由此改进产生工厂方法
• 工厂方法不符合软件设计 “ 高内聚，低耦合 ” 原则，由此改进产生抽象工厂

简单工厂

/*系列产品1*/
class Car
{
    public:
        Car(string name) : _name(name) {}
        virtual void show() = 0;
    protected:
        string _name;
};

class Bmw : public Car
{
    public:
        Bmw(string name) : Car(name) {}
        void show()
        {
            cout << "获取了一辆宝马汽车：" << _name << endl;
        }
};
class Audi : public Car
{
    public:
        Audi(string name) : Car(name) {}
        void show()
        {
            cout << "获取了一辆奥迪汽车：" << _name << endl;
        }
};

enum CarType
{
    BMW,AUDI
};
class SimpleFactory     // 软件设计 "开-闭原则"  对修改关闭 对扩展开放
{                     // 当前简单工厂模式，对修改和扩展都开放 增加对象和删除对象都需要重写这个接口
    public:            //
        Car* createCar(CarType ct)
        {
            switch (ct)
            {
                case BMW: 
                    return new Bmw("X1");
                case AUDI:
                    return new Audi("A6");
                default:
                    cerr << "传入工厂的参数不正确：" << ct << endl;
                    break;
            }
            return nullptr;
        }
};

int main()
{
    // Car *p1 = new Bmw("X1");
    // Car *p2 = new Audi("A6");

    unique_ptr<SimpleFactory> factory(new SimpleFactory()); // 创建工厂实例
    unique_ptr<Car> p1(factory->createCar(BMW));            // 应该一个工厂负责一种产品的创建
    unique_ptr<Car> p2(factory->createCar(AUDI));

    p1->show();
    p2->show();

    /*使用了智能指针之后不需要我们手动释放*/
    // delete p1;
    // delete p2;
    // delete factory;

    return 0;
}

步骤：

1. 首先创建一个车父类，定义两个子类（宝马、奥迪）继承于父类，并且重写父类虚函数；
2. 然后提供一个枚举，定义一些标识符；
3. 向外部提供一个简单工厂接口，通过用户实际输入的标识符来具体创建实例（哪一款车）；

特点：用户不需要具体关心实例是怎么创建的，只需要输入标识符就可以得到实例，但这种设计不符合开-闭原则，对修改和扩展都是开放的，增加对象类型和删除对象类型都需要重写这个接口。

就是把所有对象的创建都封装在了一个SimpleFactory类的createCar函数中，根据传入的参数，选择产生不同的对象，很明显，createCar这个函数做不到“开-闭”原则，即对原有代码修改关闭，对功能扩展开放，这个函数随着新对象的添加，或者原有对象的删除，都会导致该函数的代码修改，而且有可能影响原来的功能，所以这样的设计不能算完美。

那么接下来看看工厂方法（Factory Method）模式是否能够解决上面简单工厂的问题。

工厂方法

Factory Method工厂方法是标准的OOP设计模式之一，主要解决了上面使用简单工厂遇到的问题。工厂方法为每一种产品提供相应的实例工厂进行对象创建，更符合实际的面向对象设计，比如说不同厂家的汽车，肯定都有自己的汽车生产工厂，BMW和Audi两种汽车都有自己的工厂在生产。

#include <iostream>
#include <string>
#include <memory>
using namespace std;

// 产品类型
class Product
{
public:
	Product(string name) :_name(name) {}
	// 模拟产品对象的一个抽象方法
	virtual void show() = 0;
protected:
	string _name;
};
// 产品实体类型定义
class ProductA : public Product
{
public:
	ProductA(string name) :Product(name){}
	void show() { cout << "获取了一个使用老外高通芯片的手机:" << _name << endl; }
};
// 产品实体类型定义
class ProductB : public Product
{
public:
	ProductB(string name) :Product(name) {}
	void show() { cout << "获取了一个使用自研麒麟芯片的手机:" << _name << endl;
	}
};

// 工厂基类
class Factory
{
public:
	virtual Product* createProduct() = 0;
};

// 生产小米手机的工厂
class XiaomiFactory : public Factory
{
public:
	Product* createProduct()
	{
		// 小米工厂肯定生产小米手机
		return new ProductA("小米手机");
	}
};
// 生产华为手机的工厂
class HuaweiFactory : public Factory
{
public:
	Product* createProduct()
	{
		// 华为工厂肯定生产华为手机
		return new ProductB("华为手机");
	}
};

int main()
{
	// 使用智能指针自动释放堆内存
	// 创建具体的工厂
	unique_ptr<Factory> f1(new XiaomiFactory);
	unique_ptr<Factory> f2(new HuaweiFactory);

	// 通过工厂方法创建产品
	unique_ptr<Product> p1(f1->createProduct());
	unique_ptr<Product> p2(f2->createProduct());

	p1->show();
	p2->show();

	return 0;
}

特点：仔细理解上面的工厂方法模式，会发现一个问题，就是每一个实例工厂负责生产一个实例产品，也就是一个产品对应一个工厂，一个工厂对应一个产品，那么小米不仅仅生产手机，还生产耳机，智能手环，智能插座等等相关的小米产品簇，不可能给这每一个产品都创建一个工厂类，那样的话代码中的类就太多了，不好维护，而且也不符合实际情况。

所以对于包含产品簇这么一类实体关系的设计，就需要使用Abstract Factory抽象工厂了，你也可以把上面的工厂方法看作只生产一种产品的抽象工厂，本质是相同的。

抽象工厂

经过上面内容的描述，抽象工厂其实就是解决产品簇的产品类设计的。

#include <iostream>
#include <string>
#include <memory>
using namespace std;

// 产品簇手机类型
class ProductA
{
public:
	ProductA(string name) :_name(name) {}
	// 模拟产品对象的一个抽象方法
	virtual void show() = 0;
protected:
	string _name;
};
// 产品实体类型定义
class XiaomiPhone : public ProductA
{
public:
	XiaomiPhone(string name) :ProductA(name){}
	void show() { cout << "获取了一个小米手机:" << _name << endl; }
};
// 产品实体类型定义
class HuaweiPhone : public ProductA
{
public:
	HuaweiPhone(string name) :ProductA(name) {}
	void show() { cout << "获取了一个华为手机:" << _name << endl;
	}
};

// 产品簇智能手环类型
class ProductB
{
public:
	ProductB(string name) :_name(name) {}
	// 模拟产品对象的一个抽象方法
	virtual void show() = 0;
protected:
	string _name;
};
// 产品实体类型定义
class XiaomiCircle : public ProductB
{
public:
	XiaomiCircle(string name) :ProductB(name) {}
	void show() { cout << "获取了一个小米智能手环设备:" << _name << endl; }
};
// 产品实体类型定义
class HuaweiCircle : public ProductB
{
public:
	HuaweiCircle(string name) :ProductB(name) {}
	void show() {
		cout << "获取了一个华为智能手环设备:" << _name << endl;
	}
};

// 抽象工厂，创建通过一个产品簇的设备产品
class AbstractFactory
{
public:
	// 工厂里面创建手机的纯虚函数接口
	virtual ProductA* createPhone() = 0;
	// 工厂里面创建智能手环的纯虚函数接口
	virtual ProductB* createSmartCircle() = 0;
};

// 生产小米产品簇的工厂
class XiaomiFactory : public AbstractFactory
{
public:
	ProductA* createPhone()
	{
		// 小米工厂肯定生产小米手机
		return new XiaomiPhone("小米x9");
	}
	ProductB* createSmartCircle()
	{
		// 小米工厂肯定生产小米智能手环
		return new XiaomiCircle("小米智能手环2代时尚版");
	}
};
// 生产华为产品簇的工厂
class HuaweiFactory : public AbstractFactory
{
public:
	ProductA* createPhone()
	{
		// 华为工厂肯定生产华为手机
		return new HuaweiPhone("华为荣耀7x");
	}
	ProductB* createSmartCircle()
	{
		// 华为工厂肯定生产华为智能手环
		return new HuaweiCircle("华为智能手环B3青春版");
	}
};

int main()
{
	// 使用智能指针自动释放堆内存
	// 创建具体的工厂
	unique_ptr<AbstractFactory> f1(new XiaomiFactory);
	unique_ptr<AbstractFactory> f2(new HuaweiFactory);

	// 通过工厂方法创建手机产品
	unique_ptr<ProductA> p1(f1->createPhone());
	unique_ptr<ProductA> p2(f2->createPhone());
	p1->show();
	p2->show();

	// 通过工厂方法创建智能手环产品
	unique_ptr<ProductB> p3(f1->createSmartCircle());
	unique_ptr<ProductB> p4(f2->createSmartCircle());
	p3->show();
	p4->show();

	return 0;
}

可以看到，抽象工厂模式把一个产品簇的产品放在一个工厂类中去创建，不仅大大减少了工厂类的个数，更符合现实中工厂生产产品的模式。

其实仔细想想，抽象工厂也存在一些问题，比如有的工厂生产某一种产品，但有的工厂它不生产该种产品（可能生产其它的产品），但由于都是从一个抽象工厂继承下来的，所以就会多继承一些无用的接口。