工厂模式（Factory）

1、简单工厂模式

简单工厂模式是一种创建型设计模式，用于解决对象的创建问题。它提供了一种简单的方式来创建对象，而不需要在客户端代码中指定具体的类。

简单工厂模式的主要特点是它将对象的创建和使用分离。通过提供一个公共的工厂类，客户端代码只需要调用工厂方法即可获取所需的实例对象，而不需要直接使用 new 操作符创建对象。这种方式可以降低客户端代码与具体类之间的耦合度，使得系统更加灵活和可扩展。

简单工厂模式的优点包括：

1. 代码结构简单：通过使用简单工厂模式，我们可以避免在客户端代码中重复编写创建对象的代码，简化了代码结构。
2. 减少错误：由于客户端代码只需要调用工厂方法，而不需要自己创建对象，这样可以减少因为创建对象时参数错误导致的错误。
3. 扩展性：通过使用简单工厂模式，我们可以轻松地添加新的产品，只需要在工厂类中添加新的方法即可，而不需要修改客户端代码。

缺点：

1. 违反开闭原则：由于简单工厂模式需要在程序运行时动态地创建对象，因此需要修改工厂类来添加新的产品，这违反了开闭原则。
2. 违反单一职责原则：工厂类需要负责创建对象，同时也要负责管理对象的生命周期。这使得工厂类具有较大的职责，违反了单一职责原则。
3. 维护困难：如果系统中有很多的类需要创建，就需要有很多的工厂方法，使得工厂类变得复杂和难以维护。

示例：

#include <iostream>  
#include <string>  
  
// 抽象产品接口  
class Product {  
public:  
    virtual void use() = 0;  
};  
  
// 产品A  
class ConcreteProductA : public Product {  
public:  
    void use() override {  
        std::cout << "Using ConcreteProductA" << std::endl;  
    }  
};  
  
// 产品B  
class ConcreteProductB : public Product {  
public:  
    void use() override {  
        std::cout << "Using ConcreteProductB" << std::endl;  
    }  
};  
  
// 工厂类  
class Factory {  
public:  
    // 创建产品A的实例  
    static Product* createProductA() {  
        return new ConcreteProductA();  
    }  
      
    // 创建产品B的实例  
    static Product* createProductB() {  
        return new ConcreteProductB();  
    }  
};  
  
int main() {  
    // 创建产品A的实例并使用  
    Product* productA = Factory::createProductA();  
    productA->use();  
    delete productA; // 释放内存  
      
    // 创建产品B的实例并使用  
    Product* productB = Factory::createProductB();  
    productB->use();  
    delete productB; // 释放内存  
      
    return 0;  
}

在上述示例中，我们定义了一个抽象产品接口 Product，以及两个具体产品类 ConcreteProductA 和 ConcreteProductB，它们都继承自 Product。我们还定义了一个工厂类 Factory，其中包含了创建产品 A 和产品 B 的静态方法。在 main 函数中，我们通过调用工厂类的方法来创建产品对象，并调用它们的使用方法。这样可以避免在客户端代码中重复编写创建对象的代码，简化了代码结构。

2、工厂方法模式

工厂方法模式是一种创建型设计模式，它提供了一种创建对象的最佳方式。在工厂方法模式中，真正的创建工作交给了子类去完成，每个子类都有责任创建自己的对象。

工厂方法模式的主要特点是它将对象的创建和使用分离。通过提供一个抽象的工厂接口，客户端代码只需要调用工厂方法即可获取所需的实例对象，而不需要直接使用 new 操作符创建对象。这种方式可以降低客户端代码与具体类之间的耦合度，使得系统更加灵活和可扩展。

工厂方法模式的优点包括：

1. 代码结构清晰：通过使用工厂方法模式，我们可以将对象的创建和使用分离，使得代码结构更加清晰。
2. 灵活性高：通过实现抽象工厂接口，我们可以轻松地添加新的产品，只需要在抽象工厂类中添加新的方法即可，而不需要修改客户端代码。
3. 降低耦合度：工厂方法模式将对象的创建和使用分离，使得客户端代码与具体类之间的耦合度降低，提高了代码的可维护性和可读性。

对于简单对象，特别是只需要通过 new 就可以完成创建的对象，无需使用工厂模式。因为使用工厂模式需要引入一个抽象工厂类，会增加系统的复杂度。同时，过度使用工厂模式可能会导致代码结构变得复杂和混乱。

示例：

#include <iostream>  
#include <string>  
  
// 抽象工厂接口  
class AbstractFactory {  
public:  
    virtual ~AbstractFactory() = default;  
    virtual std::string createProduct() = 0;  
};  
  
// 具体工厂类A  
class ConcreteFactoryA : public AbstractFactory {  
public:  
    std::string createProduct() override {  
        return "ProductA created by FactoryA";  
    }  
};  
  
// 具体工厂类B  
class ConcreteFactoryB : public AbstractFactory {  
public:  
    std::string createProduct() override {  
        return "ProductB created by FactoryB";  
    }  
};  
  
// 抽象产品接口  
class Product {  
public:  
    virtual void use() = 0;  
};  
  
// 产品A的实现类  
class ConcreteProductA : public Product {  
public:  
    void use() override {  
        std::cout << "Using ConcreteProductA" << std::endl;  
    }  
};  
  
// 产品B的实现类  
class ConcreteProductB : public Product {  
public:  
    void use() override {  
        std::cout << "Using ConcreteProductB" << std::endl;  
    }  
};

3、抽象工厂模式

抽象工厂模式是一种创建型设计模式，它提供了一种创建一系列相关或互相依赖对象的最佳方式。在抽象工厂模式中，一个工厂类负责创建其他工厂类所代表的整个对象结构。

抽象工厂模式的主要特点是它将对象的创建和使用分离。通过提供一个抽象的工厂接口，客户端代码只需要调用工厂方法即可获取所需的实例对象，而不需要直接使用 new 操作符创建对象。这种方式可以降低客户端代码与具体类之间的耦合度，使得系统更加灵活和可扩展。

抽象工厂模式的优点包括：

1. 代码结构清晰：通过使用抽象工厂模式，我们可以将对象的创建和使用分离，使得代码结构更加清晰。
2. 灵活性高：通过实现抽象工厂接口，我们可以轻松地添加新的产品系列，只需要在抽象工厂类中添加新的方法即可，而不需要修改客户端代码。
3. 降低耦合度：抽象工厂模式将对象的创建和使用分离，使得客户端代码与具体类之间的耦合度降低，提高了代码的可维护性和可读性。

示例：

#include <iostream>  
#include <string>  
  
// 抽象工厂接口  
class ElectricalFactory {  
public:  
    virtual ~ElectricalFactory() = default;  
    virtual std::string createProduct() = 0;  
};  
  
// 具体工厂类A  
class ElectricalFactoryA : public ElectricalFactory {  
public:  
    std::string createProduct() override {  
        return "Electrical product created by FactoryA";  
    }  
};  
  
// 具体工厂类B  
class ElectricalFactoryB : public ElectricalFactory {  
public:  
    std::string createProduct() override {  
        return "Electrical product created by FactoryB";  
    }  
};  
  
// 抽象产品接口  
class ElectricalProduct {  
public:  
    virtual void use() = 0;  
};  
  
// 产品A的实现类  
class ElectricalProductA : public ElectricalProduct {  
public:  
    void use() override {  
        std::cout << "Using ElectricalProductA" << std::endl;  
    }  
};  
  
// 产品B的实现类  
class ElectricalProductB : public ElectricalProduct {  
public:  
    void use() override {  
        std::cout << "Using ElectricalProductB" << std::endl;  
    }  
};