一、什么是工厂模式

工厂模式是一种创建型设计模式，它提供了一个通用的接口来创建对象，而不需要直接指定他们的具体类。在软件开发中，我们经常会遇到需要创建复杂对象的情况，对于这个问题，我们可以使用工厂模式来实现。工厂模式有三个重要的角色：工厂接口、具体工厂和产品接口。其中，工厂接口定义了工厂的统一操作，具体工厂实现了工厂的接口，用来创建产品的实例，而产品接口则定义了所创建的对象的共同接口。

二、工厂模式的实现

工厂模式分为两类：简单工厂模式和工厂方法模式。简单工厂模式使用一个类来封装对象的创建过程，而工厂方法模式则使用抽象工厂接口和实现该接口的具体工厂来创建对象。

三、简单工厂模式

简单工厂模式又称为静态工厂方法模式，它通过一个工厂类来创建不同类型的对象，该类提供静态方法用来创建对象。其实现方式如下：

class Operation {
public:
    virtual double getResult(double num1, double num2) = 0;
};
class Add : public Operation {
public:
    double getResult(double num1, double num2) {
        return num1 + num2;
    }
};
class Sub : public Operation {
public:
    double getResult(double num1, double num2) {
        return num1 - num2;
    }
};
class Mul : public Operation {
public:
    double getResult(double num1, double num2) {
        return num1 * num2;
    }
};
class Div : public Operation {
public:
    double getResult(double num1, double num2) {
        if (num2 == 0) {
            throw runtime_error("除数不能为0");
        }
        return num1 / num2;
    }
};
class OperationFactory {
public:
    static Operation* createOperation(char op) {
        Operation* oper = nullptr;
        switch (op) {
        case '+':
            oper = new Add();
            break;
        case '-':
            oper = new Sub();
            break;
        case '*':
            oper = new Mul();
            break;
        case '/':
            oper = new Div();
            break;
        default:
            throw runtime_error("不支持的运算符");
        }
        return oper;
    }
};
int main() {
    Operation* oper = nullptr;
    oper = OperationFactory::createOperation('+');
    double result = oper->getResult(1, 2);
    cout << result << endl;
    delete oper;
    oper = nullptr;
    return 0;
}

在上述代码中，我们通过Operation工厂类来创建Add、Sub、Mul、Div等不同类型的对象。通过向OperationFactory::createOperation方法传入运算符，来创建相应的对象。

四、工厂方法模式

工厂方法模式是在简单工厂模式的基础之上演化而来的。工厂方法模式定义了一个抽象工厂接口，每个具体工厂都是这个抽象工厂接口的子类。在工厂方法模式中，每个具体工厂只负责创建一个产品，它通过实现工厂接口中的方法，来创建具体的产品。

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() {
    Factory* factory = nullptr;
    Product* product = nullptr;
    factory = new FactoryA();
    product = factory->createProduct();
    product->use();
    delete factory;
    delete product;
    factory = nullptr;
    product = nullptr;
    factory = new FactoryB();
    product = factory->createProduct();
    product->use();
    delete factory;
    delete product;
    factory = nullptr;
    product = nullptr;
    return 0;
}

在上述代码中，Factory是一个抽象类，它定义了一个用于创建产品对象的createProduct方法。FactoryA和FactoryB则是Factory的子类，它们分别实现了createProduct方法，用于创建ProductA和ProductB对象。

五、总结

工厂模式是一种常用的设计模式，它将对象的创建过程封装起来，使得程序的拓展性更好，代码更加简洁清晰，使用起来也更加方便。在实际的编码过程中，我们可根据具体的业务需求，选择合适的工厂模式进行应用。