工厂模式C++示例代码:简单工厂模式、工厂方法模式和抽象工厂模式

目录

 简单工厂模式（Simple Factory Pattern）

工厂方法模式（Factory Method Pattern）

抽象工厂模式（Abstract Factory Pattern）

注意的点：

适用场景：

---

当谈到工厂模式时，通常会涉及到三种常见的工厂模式：简单工厂模式、工厂方法模式和抽象工厂模式。下面我们将依次展开这三种工厂模式，并给出用C++实现的示例代码。

 简单工厂模式（Simple Factory Pattern）

简单工厂模式是最简单的工厂模式，它通过一个工厂类来创建不同类型的对象。下面是一个简单的示例代码：

#include <iostream>

// 抽象产品类
class Product {
public:
    virtual void operation() = 0;
};

// 具体产品类 A
class ConcreteProductA : public Product {
public:
    void operation() override {
        std::cout << "ConcreteProductA operation" << std::endl;
    }
};

// 具体产品类 B
class ConcreteProductB : public Product {
public:
    void operation() override {
        std::cout << "ConcreteProductB operation" << std::endl;
    }
};

// 简单工厂类
class SimpleFactory {
public:
    Product* createProduct(int type) {
        if (type == 1) {
            return new ConcreteProductA();
        } else if (type == 2) {
            return new ConcreteProductB();
        } else {
            return nullptr;
        }
    }
};

int main() {
    SimpleFactory factory;
    Product* productA = factory.createProduct(1);
    productA->operation();  // 输出：ConcreteProductA operation

    Product* productB = factory.createProduct(2);
    productB->operation();  // 输出：ConcreteProductB operation

    delete productA;
    delete productB;

    return 0;
}

工厂方法模式（Factory Method Pattern）

工厂方法模式通过定义一个创建对象的接口，让子类决定实例化哪个类。下面是一个简单的示例代码：

#include <iostream>

// 抽象产品类
class Product {
public:
    virtual void operation() = 0;
};

// 具体产品类 A
class ConcreteProductA : public Product {
public:
    void operation() override {
        std::cout << "ConcreteProductA operation" << std::endl;
    }
};

// 具体产品类 B
class ConcreteProductB : public Product {
public:
    void operation() override {
        std::cout << "ConcreteProductB operation" << std::endl;
    }
};

// 工厂接口
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();  // 输出：ConcreteProductA operation

    Factory* factoryB = new ConcreteFactoryB();
    Product* productB = factoryB->createProduct();
    productB->operation();  // 输出：ConcreteProductB operation

    delete factoryA;
    delete productA;
    delete factoryB;
    delete productB;

    return 0;
}

抽象工厂模式（Abstract Factory Pattern）

抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们的具体类。下面是一个简单的示例代码：

#include <iostream>

// 抽象产品类 A
class AbstractProductA {
public:
    virtual void operationA() = 0;
};

// 具体产品类 A1
class ConcreteProductA1 : public AbstractProductA {
public:
    void operationA() override {
        std::cout << "ConcreteProductA1 operationA" << std::endl;
    }
};

// 具体产品类 A2
class ConcreteProductA2 : public AbstractProductA {
public:
    void operationA() override {
        std::cout << "ConcreteProductA2 operationA" << std::endl;
    }
};

// 抽象产品类 B
class AbstractProductB {
public:
    virtual void operationB() = 0;
};

// 具体产品类 B1
class ConcreteProductB1 : public AbstractProductB {
public:
    void operationB() override {
        std::cout << "ConcreteProductB1 operationB" << std::endl;
    }
};

// 具体产品类 B2
class ConcreteProductB2 : public AbstractProductB {
public:
    void operationB() override {
        std::cout << "ConcreteProductB2 operationB" << std::endl;
    }
};

// 抽象工厂类
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();  // 输出：ConcreteProductA1 operationA
    productB1->operationB();  // 输出：ConcreteProductB1 operationB

    AbstractFactory* factory2 = new ConcreteFactory2();
    AbstractProductA* productA2 = factory2->createProductA();
    AbstractProductB* productB2 = factory2->createProductB();
    productA2->operationA();  // 输出：ConcreteProductA2 operationA
    productB2->operationB();  // 输出：ConcreteProductB2 operationB

    delete factory1;
    delete productA1;
    delete productB1;

    delete factory2;
    delete productA2;
    delete productB2;

    return 0;
}

注意的点：

在使用工厂模式时，需要注意以下几点：

1. 选择合适的工厂模式：根据具体的需求选择合适的工厂模式，包括简单工厂模式、工厂方法模式和抽象工厂模式。不同的场景可能需要不同的工厂模式来满足需求。

2. 遵循单一职责原则：工厂类应该有一个明确的职责，即负责创建特定类型的对象。不要将过多的逻辑放入工厂类中，以免违反单一职责原则。

3. 合理命名：工厂类、产品类等命名应该清晰明了，以便于其他开发人员理解和维护代码。

4. 对产品类进行合理划分：产品类的设计应该合理，遵循高内聚、低耦合的原则，确保产品类之间的关系清晰明了。

5. 考虑扩展性：在设计工厂模式时，应该考虑系统的扩展性，确保能够方便地添加新的产品类或工厂类。

6. 适当使用抽象类或接口：在工厂方法模式和抽象工厂模式中，适当使用抽象类或接口可以帮助我们定义产品类的通用接口，从而降低代码耦合度。

7. 考虑性能和内存消耗：在实际应用中，需要考虑工厂模式对性能和内存消耗的影响，避免不必要的对象创建和销毁。

总的来说，使用工厂模式时需要注意设计合理的类结构、遵循设计原则、考虑系统的扩展性和性能等方面的问题。

适用场景：

工厂模式适用于以下场景：

1. 需要根据不同的条件创建不同类型的对象：当需要根据不同的条件或参数创建不同类型的对象时，可以使用工厂模式。这样可以将对象的具体创建过程封装在工厂类中，客户端代码无需关心对象的创建细节。

2. 需要隐藏对象的创建细节：工厂模式可以帮助我们隐藏对象的创建细节，从而降低客户端代码与具体产品类之间的耦合度。

3. 需要遵循开闭原则：当系统需要支持新类型的产品时，我们可以通过添加新的工厂类来实现对扩展开放，对修改关闭的原则。

4. 需要创建一系列相关或相互依赖的对象：工厂模式可以用于创建一系列相关或相互依赖的对象，确保这些对象之间的兼容性和一致性。

5. 需要统一管理对象的生命周期：通过工厂模式，我们可以统一管理对象的生命周期，例如对象的缓存、池化等。

总的来说，工厂模式适用于需要根据条件创建不同类型的对象、隐藏对象创建细节、支持系统扩展、统一管理对象生命周期等场景。在实际开发中，根据具体需求选择合适的工厂模式可以提高代码的可维护性和可扩展性。