C++设计模式（工厂模式）

1.工厂模式简介      

         工厂模式的三种类型：简单工厂模式、工厂方法模式和抽象工厂模式。工厂模式的作用是生产对象，可以简化代码、提高可维护性，并旦可以通过工厂类生产多种对象。简单工厂模式适用于创建简单的对象，工厂模式适用于创建复杂的对象，而抽象工厂模式适用于创建更复杂的对象。

2. 简单工厂模式

        简单工厂模式是一种创建型设计模式，旨在通过一个工厂方法来创建对象，而无需直接暴露对象的实例化逻辑。简单工厂模式通常包括一个工厂类和多个产品类。工厂类负责根据客户端的请求，返回对应的产品类实例。
        在简单工厂模式中，客户端只需要通过调用工厂类的方法，并传入相应的参数，而无需直接实例化产品类。工厂类根据客户端传入的参数决定创建哪个产品类的实例，并将实例返回给客户端。

        简单工厂模式的优点在于，它封装了实例化的细节，使得客户端与具体产品类解耦，增强了灵活性和可维护性。客户端只需要知道需要什么类型的产品，而无需关心具体的实现细节。同时，如果需要新增产品类时，只需修改工厂类即可，不需要修改客户端代码。      

        然而，简单工厂模式也有一些限制。例如，当需要创建多种类型的产品实例时，工厂类的代码可能会变得复杂，并且随着产品类型的增加，工厂类的责任也会越来越大。因此，在一些复杂的场景下，可能需要使用其他更灵活的创建型设计模式，如工厂方法模式或抽象工厂模式。
        总的来说，简单工厂模式提供了一种简单而灵活的方式来创建对象，对于一些简单的对象创建场景是很有用的。

代码示例：

在C++语言中，简单工厂模式可以通过以下方式来实现：
首先，定义一个产品的基类或接口，所有具体产品类都应该实现这个基类或接口。

class Product {
public:
    virtual void operation() = 0;
};
class ConcreteProductA : public Product {
public:
    void operation() override {
        // 具体产品A的操作实现
    }
};
class ConcreteProductB : public Product {
public:
    void operation() override {
        // 具体产品B的操作实现
    }
};

然后，实现一个简单工厂类，该工厂类包含一个静态方法用于创建产品实例。

class SimpleFactory {
public:
    static Product* createProduct(const std::string& type) {
        if (type == "A") {
            return new ConcreteProductA();
        } else if (type == "B") {
            return new ConcreteProductB();
        } else {
            return nullptr; // 可以添加默认处理逻辑或抛出异常
        }
    }
};

最后，客户端可以通过简单工厂类来创建具体的产品对象。

int main() {
    Product* productA = SimpleFactory::createProduct("A");
    productA->operation(); // 调用具体产品A的操作
    Product* productB = SimpleFactory::createProduct("B");
    productB->operation(); // 调用具体产品B的操作
    delete productA;
    delete productB;
    return 0;
}

        在上面的示例中，通过调用`SimpleFactory::createProduct()`方法并传入不同的类型参数，就可以创建相应类型的产品对象。这样，客户端就可以通过工厂类来创建和使用产品对象，而无需直接处理具体产品类的实例化逻辑。
        需要注意的是，简单工厂模式通常是静态方法创建产品对象，但这并不是必须的，你也可以通过实例化工厂类来创建产品对象。另外，如果需要增加新的产品类型，只需要修改工厂类的逻辑即可，而不需要修改客户端代码。

3. 工厂方法模式

        工厂方法模式（Factory Method Pattern）是一种创建型设计模式，它定义了一个用于创建对象的接口，但将具体的对象创建过程交给子类来实现。工厂方法模式通过让子类决定实例化哪个具体类来实现对象的创建，从而实现了将对象的创建和使用解耦的目的。
工厂方法模式一般包括以下角色：

1. 抽象产品（Product）：定义了产品的共同接口，具体的产品类必须实现这个接口。
2. 具体产品（ConcreteProduct）：实现了抽象产品接口，是工厂方法模式中具体创建的对象。
3. 抽象工厂（Factory）：定义了一个工厂的接口，包含一个创建产品的抽象方法，具体的工厂类必须实现这个接口。
4. 具体工厂（ConcreteFactory）：实现了抽象工厂接口，负责实例化具体的产品对象。

        工厂方法模式的关键在于通过抽象工厂和具体工厂的组合，将对象的创建过程推迟到子类中实现。客户端通过使用抽象工厂来创建产品对象，而无需关心具体的产品类和实例化细节。

代码示例：

// 抽象产品
class Product {
public:
    virtual void operation() = 0;
};
// 具体产品 A
class ConcreteProductA : public Product {
public:
    void operation() override {
        // 具体产品 A 的操作实现
    }
};
// 具体产品 B
class ConcreteProductB : public Product {
public:
    void operation() override {
        // 具体产品 B 的操作实现
    }
};
// 抽象工厂
class Factory {
public:
    virtual Product* createProduct() = 0;
};
// 具体工厂 A
class ConcreteFactoryA : public Factory {
public:
    Product* createProduct() override {
        return new ConcreteProductA();
    }
};
// 具体工厂 B
class ConcreteFactoryB : public Factory {
public:
    Product* createProduct() override {
        return new ConcreteProductB();
    }
};

客户端使用工厂方法模式来创建产品对象：

int main() {
    Factory* factoryA = new ConcreteFactoryA();
    Product* productA = factoryA->createProduct();
    productA->operation(); // 调用具体产品 A 的操作
    Factory* factoryB = new ConcreteFactoryB();
    Product* productB = factoryB->createProduct();
    productB->operation(); // 调用具体产品 B 的操作
    delete factoryA;
    delete productA;
    delete factoryB;
    delete productB;
    return 0;
}

       在上述示例中，抽象工厂 Factory 定义了一个用于创建产品对象的抽象方法 createProduct()。具体的工厂类 ConcreteFactoryA 和 ConcreteFactoryB 分别实现了 createProduct() 方法，并通过返回具体的产品对象来实现对象的创建。客户端通过使用抽象工厂 Factory 来创建产品对象，而无需直接关心具体的产品类和实例化细节。
        工厂方法模式的优点包括增强了代码的可扩展性和可维护性，将对象的创建和使用解耦，允许在不修改现有代码的情况下引入新的产品和工厂。然而，工厂方法模式也会增加类的个数，导致代码的复杂性增加。在使用工厂方法模式时，需要根据具体情况选择合适的抽象工厂和具体工厂来创建对象。

4. 抽象工厂模式

        抽象工厂模式（Abstract Factory Pattern）是一种创建型设计模式，它提供了一个接口，用于创建一系列相关或相互依赖的对象，而无需指定具体的类。抽象工厂模式通过将对象的创建和使用解耦，使得客户端代码与具体类的实现分离，从而实现了对象的变化和替换的灵活性。
        抽象工厂模式一般包括以下角色：

1. 抽象工厂（Abstract Factory）：定义了创建一系列产品对象的接口，通常包含多个创建产品的抽象方法。
2. 具体工厂（Concrete Factory）：实现了抽象工厂接口，负责创建具体的产品对象。
3. 抽象产品（Abstract Product）：定义了产品的共同接口，具体的产品类必须实现这个接口。
4. 具体产品（Concrete Product）：实现了抽象产品接口，是抽象工厂模式中具体创建的对象。

代码示例：

// 抽象产品 A
class AbstractProductA {
public:
    virtual void operationA() = 0;
};
// 具体产品 A1
class ConcreteProductA1 : public AbstractProductA {
public:
    void operationA() override {
        // 具体产品 A1 的操作实现
    }
};
// 具体产品 A2
class ConcreteProductA2 : public AbstractProductA {
public:
    void operationA() override {
        // 具体产品 A2 的操作实现
    }
};
// 抽象产品 B
class AbstractProductB {
public:
    virtual void operationB() = 0;
};
// 具体产品 B1
class ConcreteProductB1 : public AbstractProductB {
public:
    void operationB() override {
        // 具体产品 B1 的操作实现
    }
};
// 具体产品 B2
class ConcreteProductB2 : public AbstractProductB {
public:
    void operationB() override {
        // 具体产品 B2 的操作实现
    }
};
// 抽象工厂
class AbstractFactory {
public:
    virtual AbstractProductA* createProductA() = 0;
    virtual AbstractProductB* createProductB() = 0;
};
// 具体工厂 1
class ConcreteFactory1 : public AbstractFactory {
public:
    AbstractProductA* createProductA() override {
        return new ConcreteProductA1();
    }
    AbstractProductB* createProductB() override {
        return new ConcreteProductB1();
    }
};
// 具体工厂 2
class ConcreteFactory2 : public AbstractFactory {
public:
    AbstractProductA* createProductA() override {
        return new ConcreteProductA2();
    }
    AbstractProductB* createProductB() override {
        return new ConcreteProductB2();
    }
};

客户端使用抽象工厂模式来创建一系列产品对象：

int main() {
    AbstractFactory* factory1 = new ConcreteFactory1();
    AbstractProductA* productA1 = factory1->createProductA();
    AbstractProductB* productB1 = factory1->createProductB();
    productA1->operationA(); // 调用具体产品 A1 的操作
    productB1->operationB(); // 调用具体产品 B1 的操作
    delete factory1;
    delete productA1;
    delete productB1;
    AbstractFactory* factory2 = new ConcreteFactory2();
    AbstractProductA* productA2 = factory2->createProductA();
    AbstractProductB* productB2 = factory2->createProductB();
    productA2->operationA(); // 调用具体产品 A2 的操作
    productB2->operationB(); // 调用具体产品 B2 的操作
    delete factory2;
    delete productA2;
    delete productB2;
    return 0;
}

        在上述示例中，抽象工厂 AbstractFactory 定义了创建一系列产品对象的抽象方法 createProductA() 和 createProductB()。具体的工厂类 ConcreteFactory1 和 ConcreteFactory2 分别实现了这两个抽象方法，通过返回具体的产品对象来实现对象的创建。客户端通过使用抽象工厂 AbstractFactory 来创建一系列产品对象，而无需直接关心具体的产品类和实例化细节。
        抽象工厂模式可以有效地封装一系列产品的创建过程，使得客户端与具体产品的实现解耦。同时，抽象工厂模式也提供了一种机制，使得一组相关的产品对象可以被一起替换，而无需修改客户端代码。然而，抽象工厂模式的扩展性较差，对于新增加的产品或者产品族会产生较大的修改。在使用抽象工厂模式时，需要根据具体情况选择合适的抽象工厂和具体工厂来创建对象。