C++中实现工厂模式的几种方法

工厂模式是一种常见的设计模式，主要用于创建对象。它通过将对象的创建过程封装在工厂类中，从而实现对象创建与使用分离的目的。在C++中，可以采用多种方法来实现工厂模式。以下我们将详细介绍几种常见的方式，并结合代码示例进行说明。

1. 简单工厂模式

简单工厂模式的核心思想是通过一个工厂类来负责创建不同类型的对象。虽然这种模式不完全符合“开闭原则”，但它非常适合初学者理解和使用。

实现步骤：

1. 定义一个基类接口。
2. 创建多个派生类实现该接口。
3. 在工厂类中根据参数决定返回哪个派生类的实例。

示例代码：

#include <iostream>
#include <string>
#include <map>

// 基类接口
class Product {
public:
    virtual void use() = 0;
    virtual ~Product() {}
};

// 具体产品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 SimpleFactory {
public:
    static Product* createProduct(const std::string& type) {
        if (type == "A") {
            return new ConcreteProductA();
        } else if (type == "B") {
            return new ConcreteProductB();
        }
        return nullptr;
    }
};

int main() {
    Product* productA = SimpleFactory::createProduct("A");
    productA->use(); // 输出: Using ConcreteProductA

    Product* productB = SimpleFactory::createProduct("B");
    productB->use(); // 输出: Using ConcreteProductB

    delete productA;
    delete productB;

    return 0;
}

2. 工厂方法模式

工厂方法模式通过定义一个用于创建对象的接口，让子类决定实例化哪一个类。这种方式更加灵活，符合“开闭原则”。

实现步骤：

1. 定义一个工厂基类和产品基类。
2. 派生出具体的工厂类和具体的产品类。
3. 在具体的工厂类中实现工厂方法，返回对应的具体产品。

示例代码：

#include <iostream>

// 产品基类
class Product {
public:
    virtual void use() = 0;
    virtual ~Product() {}
};

// 具体产品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:
    virtual Product* createProduct() = 0;
    virtual ~Factory() {}
};

// 具体工厂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->use(); // 输出: Using ConcreteProductA

    Factory* factoryB = new ConcreteFactoryB();
    Product* productB = factoryB->createProduct();
    productB->use(); // 输出: Using ConcreteProductB

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

    return 0;
}

3. 抽象工厂模式

抽象工厂模式提供了一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。它适用于需要创建一组具有相同主题的对象的情况。

实现步骤：

1. 定义一组产品接口。
2. 创建具体的工厂类实现这些接口。
3. 使用工厂类创建一组相关的产品。

示例代码：

#include <iostream>

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

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

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

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

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

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

// 抽象工厂
class AbstractFactory {
public:
    virtual AbstractProductA* createProductA() = 0;
    virtual AbstractProductB* createProductB() = 0;
    virtual ~AbstractFactory() {}
};

// 具体工厂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();
    productA1->use(); // 输出: Using ConcreteProductA1

    AbstractProductB* productB1 = factory1->createProductB();
    productB1->use(); // 输出: Using ConcreteProductB1

    AbstractFactory* factory2 = new ConcreteFactory2();
    AbstractProductA* productA2 = factory2->createProductA();
    productA2->use(); // 输出: Using ConcreteProductA2

    AbstractProductB* productB2 = factory2->createProductB();
    productB2->use(); // 输出: Using ConcreteProductB2

    delete productA1;
    delete productB1;
    delete productA2;
    delete productB2;
    delete factory1;
    delete factory2;

    return 0;
}

总结

• 简单工厂模式适合简单的对象创建场景，但扩展性较差。
• 工厂方法模式提供了更好的扩展性，适合需要动态选择具体实现的场景。
• 抽象工厂模式适用于需要创建一组相关对象的场景。