C++设计模式之简单工厂模式实例

C++设计模式之简单工厂模式实例详解

简单工厂模式(Simple Factory Pattern)是一种创建型设计模式，它提供了一种创建对象的最佳方式。简单工厂模式定义了一个工厂类，它可以根据所传递的参数或配置文件的不同，返回不同类的实例。简单工厂模式具有简单易懂，适用范围广等特点，在实际开发中也得到了广泛应用。

简单工厂模式的结构

简单工厂模式包含三个主要角色：

• 工厂类：简单工厂模式的核心，负责创建所有产品的实例。
• 抽象产品类：定义产品的接口，是具体产品的基类。
• 具体产品类：实现抽象产品类的接口，是被创建的对象。

简单工厂模式的结构图：

+------------+
|  Factory   |
+------------+
| createProd |
+------------+
       |
       | 实例化产品对象
       |
+------------+             +---------------+
| Product    | <---------  | ConcreteProd1 |
+------------+             +---------------+
| method1()  |             | method1()     |
| method2()  |             | method2()     |
+------------+             +---------------+
              实现

+------------+             +---------------+
| Product    | <---------  | ConcreteProd2 |
+------------+             +---------------+
| method1()  |             | method1()     |
| method2()  |             | method2()     |
+------------+             +---------------+

简单工厂模式示例

下面通过两个实例来详细介绍简单工厂模式的应用。

示例一：计算器程序

在计算器程序中，我们传递了两个数和运算符，根据运算符的不同返回不同的计算结果。通过使用简单工厂模式，我们可以实现这个过程。

首先，定义抽象产品类 Operation，其中定义了两个虚函数 getResult() 和 setNum()，分别用于计算结果和设置操作数。

class Operation {
public:
    virtual double getResult() = 0;
    virtual void setNum(double a, double b) {
        numA = a;
        numB = b;
    }
protected:
    double numA;
    double numB;
};

然后，定义两个具体产品类 AddOperation 和 SubOperation，分别实现抽象产品类的接口。在具体产品类中，我们可以实现具体的计算逻辑。

class AddOperation: public Operation
{
public:
    double getResult() override {
        return numA + numB;
    }
};

class SubOperation: public Operation
{
public:
    double getResult() override {
        return numA - numB;
    }
};

最后，定义工厂类 Factory，根据运算符的不同返回不同的产品实例。在工厂类中，我们使用了 switch 语句来判断运算符类型。

class Factory
{
public:
    static Operation* createOperation(char operate)
    {
        Operation* oper = nullptr;
        switch (operate) {
            case '+':
                oper = new AddOperation();
                break;
            case '-':
                oper = new SubOperation();
                break;
            default:
                cout << "invalid operate!" << endl;
                break;
        }
        return oper;
    }
};

在客户端中，我们可以通过如下代码调用工厂类，创建对应产品的实例，并调用其接口函数。

int main() {
    Operation* op = Factory::createOperation('+');
    op->setNum(1, 2);
    cout << op->getResult() << endl;
    return 0;
}

示例二：图形画笔程序

在图形画笔程序中，我们传递了一个图形类型，根据类型的不同返回不同绘制图形的画笔。同样通过使用简单工厂模式，我们可以实现这个过程。

首先，我们定义了工具类 Point，用于表示一个点。然后，定义抽象产品类 Shape，其中定义了两个纯虚函数 draw() 和 setPoint()，分别用于绘制图形和设置绘制点。

class Shape
{
public:
    virtual void draw() = 0;
    virtual void setPoint(Point p) = 0;

protected:
    Point m_point;
};

class Point
{
public:
    Point(int x = 0, int y = 0) : m_x(x), m_y(y) {}
    void setPoint(int x, int y) { m_x = x; m_y = y; }
    void setX(int x) { m_x = x; }
    void setY(int y) { m_y = y; }
    int x() const { return m_x; }
    int y() const { return m_y; }
private:
    int m_x;
    int m_y;
};

然后，定义不同的具体产品类：LineShape、CircleShape和SquareShape，分别实现抽象产品类的接口。在每个具体产品类中，我们按照不同的逻辑实现具体的图形绘制过程。

// 按照覆盖父类的虚函数来实现具体产品类
class LineShape: public Shape
{
public:
    void draw() override {
        cout << "draw line from (" << m_point.x() << ", " << m_point.y() << ")" << endl;
    }
    void setPoint(Point p) override {
        m_point = p;
    }
};

class CircleShape: public Shape
{
public:
    void draw() override {
        cout << "draw circle with center (" << m_point.x() << ", " << m_point.y() << ")" << endl;
    }
    void setPoint(Point p) override {
        m_point = p;
    }
};

class SquareShape: public Shape
{
public:
    void draw() override {
        cout << "draw square with center (" << m_point.x() << ", " << m_point.y() << ")" << endl;
    }
    void setPoint(Point p) override {
        m_point = p;
    }
};

最后，定义工厂类 ShapeFactory，根据传入的参数类型返回不同的产品实例。在工厂类中，我们使用了 switch 语句来判断图形类型。

class ShapeFactory
{
public:
    static Shape* createShape(int type)
    {
        Shape* shape;
        switch (type) {
            case 1:
                shape = new LineShape();
                break;
            case 2:
                shape = new CircleShape();
                break;
            case 3:
                shape = new SquareShape();
                break;
            default:
                cout << "invalid shape!" << endl;
                shape = nullptr;
                break;
        }
        return shape;
    }
};

在客户端中，我们可以通过如下代码调用工厂类，创建对应产品的实例，并调用其接口函数。

int main() {
    Shape* shape1 = ShapeFactory::createShape(1);
    shape1->setPoint(Point(1, 1));
    shape1->draw();
    Shape* shape2 = ShapeFactory::createShape(2);
    shape2->setPoint(Point(2, 2));
    shape2->draw();
    Shape* shape3 = ShapeFactory::createShape(3);
    shape3->setPoint(Point(3, 3));
    shape3->draw();
    return 0;
}

总结

简单工厂模式可以方便地创建一些对象，减少了代码重复和耦合度。但是简单工厂模式有些缺点，在实现时需要考虑到可扩展性和可维护性问题。因为增加新产品需要修改工厂类的代码，这样会违背开放封闭原则。所以在实际项目中需要根据实际情况选用不同的设计模式。