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

news2025/6/3 1:23:58

更多内容：XiaoJ的知识星球

1.简单工厂模式

1.1 简单工厂

简单工厂模式属于类的创建型模式，又叫做静态工厂方法模式。

通过专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。

1.2 实现步骤

1.提供一个工厂类

简单工厂模式的核心，它负责实现创建所有实例的内部逻辑。工厂类可以被外界直接调用，创建所需的产品对象。

2.提供一个抽象产品类

简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。

3.提供一个具体产品类

简单工厂模式所创建的具体实例对象

在这里插入图片描述

1.3 实现代码

#include <iostream>
#include <string>
using namespace std;
//产品抽象父类
class Operation 
{    

public:
    double m_leftVlaue;
    double m_rightValue;
    virtual double GetResult() = 0;
};
//具体产品实现类
class AddOperation:public Operation
{
    double GetResult()
    {
        return m_leftVlaue + m_rightValue;
    }
};
class SubOperation :public Operation 
{
    double GetResult()
    {
        return m_leftVlaue - m_rightValue;
    }
};

class MulOperation :public Operation
{
    double GetResult()
    {
        return m_leftVlaue * m_rightValue;
    }
};

class DivOperation :public Operation
{
    double GetResult()
    {
        return m_leftVlaue / m_rightValue;
    }
};
//工厂类
class  OperatorFactory 
{
public:
    static  Operation* createOperation(char c) 
    {
        switch (c) 
        {
        case '+':
            return new AddOperation;
            break;
        case '-':
            return new SubOperation;
            break;
        case '*':
            return new MulOperation;
            break;
        case '/':
            return new DivOperation;
            break;
        }
    }
};
int main() 
{
    Operation* operation = OperatorFactory::createOperation('+');
    operation->m_leftVlaue = 1;
    operation->m_rightValue = 2;
    cout << operation->GetResult() << endl;
    return 0;
}

1.4 优缺点

优点：

帮助封装：实现组件封装，面向接口编程
解耦合：客户端和具体实现类的解耦合

缺点：

可能增加客户端的复杂度
不方便扩展子工厂

2.工厂模式

2.1 工厂模式

工厂方法模式，同样属于类的创建型模式，又被称为多态工厂模式。

工厂方法模式的意义：

定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。
核心工厂类不再负责产品的创建，这样核心类成为一个抽象工厂角色，仅负责具体工厂子类必须实现的接口，
这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品

2.2 实现步骤

1.提供一个抽象工厂类：所有具体工厂类的父类

2.提供与产品对应的工厂类：负责实例化产品对象

3.提供一个抽象产品类：所有产品的父类

4.提供一个或多个产品类：工厂方法模式所创建的具体实例对象
在这里插入图片描述
.

2.3 实现代码

#include <iostream>
using namespace std;
class AbstractProduct
{
public:
    virtual void makeProduct() = 0;
};

class AbstractFactory 
{
public:
    virtual AbstractProduct* createProduct() = 0;
};

class PlaneProduct :public AbstractProduct
{
public:
    void makeProduct() 
    {
        cout << "造飞机....." << endl;
    }
};
class PlaneFactory :public AbstractFactory 
{
public:
    AbstractProduct* createProduct()
    {
        AbstractProduct* product = new PlaneProduct;
        return product;
    }
};
class RocketProduct :public AbstractProduct
{
public:
    void makeProduct()
    {
        cout << "造火箭...." << endl;
    }
};
class RocketFactory :public AbstractFactory 
{
public :
    AbstractProduct* createProduct()
    {
        AbstractProduct* product = new RocketProduct;
        return product;
    }
};

int main() 
{
    //造飞机
    AbstractFactory* factory = new PlaneFactory;
    AbstractProduct* product = factory->createProduct();
    product->makeProduct();
    //造火箭
    factory = new RocketFactory;
    product = factory->createProduct();
    product->makeProduct();

    return 0;
}

2.4 优缺点

优点：

需求改变时改动最小
具体的创建实例过程与客户端分离

缺点：

新增功能时，工程量稍大

3.抽象工厂模式

3.1 抽象工厂模式

抽象工厂模式是所有形态的工厂模式中最为抽象和最其一般性的。

抽象工厂模式可以向客户端提供一个接口，使得客户端在不必指定产品的具体类型的情况下，能够创建多个产品族的产品对象。

3.2 实现步骤

1.提供一个抽象工厂类：声明一组创建一族产品的工厂方法

2.提供一个具体工厂类：实现了在抽象工厂创建产品的工厂方法

3.提供一个抽象产品类：抽象产品中声明了产品具有的业务方法

4.提供一个具体产品类：实现抽象产品接口中声明的业务方法
在这里插入图片描述

3.3 实现代码

#include <iostream>
using namespace std;
//抽象产品
class Product 
{
public:
    virtual void show() = 0;
};
//抽象产品族1
class KeyBoard :public Product{};
//罗技键盘
class LogiKeyBoard :public KeyBoard
{
    void show()
    {
        cout << "罗技键盘......" << endl;
    }
};
//雷蛇键盘
class RazerKeyBoard :public KeyBoard
{
    void show() 
    {
        cout << "雷蛇键盘......" << endl;
    }
};
//抽象产品族2
class Mouse :public Product {};
//罗技鼠标
class LogiMouse :public Mouse
{
    void show() 
    {
        cout << "罗技鼠标......" << endl;
    }
};
class RazerMouse :public Mouse 
{
    void show() 
    {
        cout << "雷蛇鼠标......" << endl;
    }
};
//抽象工厂
class Factory
{
public:
    virtual KeyBoard* createKeyBoard() = 0;
    virtual Mouse* createMouse() = 0;
};
class LogiFactory :public Factory
{
    KeyBoard* createKeyBoard()
    {
        return new LogiKeyBoard;
    }
    Mouse* createMouse() 
    {
        return new LogiMouse;
    }
};
class RazerFactory :public Factory 
{
    KeyBoard* createKeyBoard() 
    {
        return new RazerKeyBoard;
    }
    Mouse* createMouse() 
    {
        return new RazerMouse;
    }
};

int main() 
{
    Factory* factory = new LogiFactory;
    KeyBoard* keyBoard = factory->createKeyBoard();
    Mouse* mouse = factory->createMouse();
    keyBoard->show();
    mouse->show();
    delete factory;
    delete keyBoard;
    delete mouse;
    factory = new RazerFactory;
    keyBoard = factory->createKeyBoard();
    mouse = factory->createMouse();
    keyBoard->show();
    mouse->show();
    delete factory;
    delete keyBoard;
    delete mouse;
    factory = NULL;
    keyBoard = NULL;
    mouse = NULL;
    return 0;
}