当前位置：首页 > article >正文

C/C++实现工厂模板设计模式（Factory Pattern)

article 2025/3/17 21:59:42

工厂模式是一种创建型设计模式，它提供了一种创建对象的方式，而无需指定具体的类。工厂模式通过定义一个创建对象的接口，让子类决定实例化哪一个类。工厂模式可以分为简单工厂模式、工厂方法模式和抽象工厂模式。

下面是一个使用C++实现的简单工厂模式的示例：

#include <iostream>
#include <memory>

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

// 具体产品A
class ProductA : public Product {
public:
    void use() override {
        std::cout << "Using Product A" << std::endl;
    }
};

// 具体产品B
class ProductB : public Product {
public:
    void use() override {
        std::cout << "Using Product B" << std::endl;
    }
};

// 工厂类
class Factory {
public:
    // 创建产品的方法
    static std::unique_ptr<Product> createProduct(const std::string& type) {
        if (type == "A") {
            return std::make_unique<ProductA>();
        } else if (type == "B") {
            return std::make_unique<ProductB>();
        } else {
            return nullptr;
        }
    }
};

int main() {
    // 使用工厂创建产品A
    std::unique_ptr<Product> productA = Factory::createProduct("A");
    if (productA) {
        productA->use();
    }

    // 使用工厂创建产品B
    std::unique_ptr<Product> productB = Factory::createProduct("B");
    if (productB) {
        productB->use();
    }

    return 0;
}

代码说明：

Product 是产品的基类，定义了产品的接口 use()。
ProductA 和 ProductB 是具体的产品类，分别实现了 use() 方法。
Factory 是工厂类，提供了一个静态方法 createProduct()，根据传入的参数决定创建哪种产品。
在 main() 函数中，通过工厂类创建了不同的产品，并调用了它们的 use() 方法。

工厂方法模式：

工厂方法模式是对简单工厂模式的进一步抽象，它将工厂类抽象为一个接口，具体的工厂子类负责创建具体的产品。

#include <iostream>
#include <memory>

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

// 具体产品A
class ProductA : public Product {
public:
    void use() override {
        std::cout << "Using Product A" << std::endl;
    }
};

// 具体产品B
class ProductB : public Product {
public:
    void use() override {
        std::cout << "Using Product B" << std::endl;
    }
};

// 工厂基类
class Factory {
public:
    virtual std::unique_ptr<Product> createProduct() = 0;
    virtual ~Factory() = default;
};

// 具体工厂A
class FactoryA : public Factory {
public:
    std::unique_ptr<Product> createProduct() override {
        return std::make_unique<ProductA>();
    }
};

// 具体工厂B
class FactoryB : public Factory {
public:
    std::unique_ptr<Product> createProduct() override {
        return std::make_unique<ProductB>();
    }
};

int main() {
    // 使用工厂A创建产品A
    std::unique_ptr<Factory> factoryA = std::make_unique<FactoryA>();
    std::unique_ptr<Product> productA = factoryA->createProduct();
    productA->use();

    // 使用工厂B创建产品B
    std::unique_ptr<Factory> factoryB = std::make_unique<FactoryB>();
    std::unique_ptr<Product> productB = factoryB->createProduct();
    productB->use();

    return 0;
}

代码说明：

Factory 是工厂基类，定义了一个纯虚函数 createProduct()，具体的工厂子类需要实现这个方法来创建具体的产品。
FactoryA 和 FactoryB 是具体的工厂类，分别负责创建 ProductA 和 ProductB。
在 main() 函数中，通过具体的工厂类创建了不同的产品，并调用了它们的 use() 方法。

抽象工厂模式：

抽象工厂模式是工厂方法模式的扩展，它提供了一个接口用于创建一系列相关或依赖的对象，而无需指定它们的具体类。

#include <iostream>
#include <memory>

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

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

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

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

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

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

// 抽象工厂基类
class AbstractFactory {
public:
    virtual std::unique_ptr<ProductA> createProductA() = 0;
    virtual std::unique_ptr<ProductB> createProductB() = 0;
    virtual ~AbstractFactory() = default;
};

// 具体工厂1
class ConcreteFactory1 : public AbstractFactory {
public:
    std::unique_ptr<ProductA> createProductA() override {
        return std::make_unique<ProductA1>();
    }
    std::unique_ptr<ProductB> createProductB() override {
        return std::make_unique<ProductB1>();
    }
};

// 具体工厂2
class ConcreteFactory2 : public AbstractFactory {
public:
    std::unique_ptr<ProductA> createProductA() override {
        return std::make_unique<ProductA2>();
    }
    std::unique_ptr<ProductB> createProductB() override {
        return std::make_unique<ProductB2>();
    }
};

int main() {
    // 使用具体工厂1创建产品A1和B1
    std::unique_ptr<AbstractFactory> factory1 = std::make_unique<ConcreteFactory1>();
    std::unique_ptr<ProductA> productA1 = factory1->createProductA();
    std::unique_ptr<ProductB> productB1 = factory1->createProductB();
    productA1->use();
    productB1->use();

    // 使用具体工厂2创建产品A2和B2
    std::unique_ptr<AbstractFactory> factory2 = std::make_unique<ConcreteFactory2>();
    std::unique_ptr<ProductA> productA2 = factory2->createProductA();
    std::unique_ptr<ProductB> productB2 = factory2->createProductB();
    productA2->use();
    productB2->use();

    return 0;
}

代码说明：

ProductA 和 ProductB 是产品基类，定义了产品的接口 use()。
ProductA1, ProductA2, ProductB1, ProductB2 是具体的产品类，分别实现了 use() 方法。
AbstractFactory 是抽象工厂基类，定义了两个纯虚函数 createProductA() 和 createProductB()，具体的工厂子类需要实现这些方法来创建具体的产品。
ConcreteFactory1 和 ConcreteFactory2 是具体的工厂类，分别负责创建 ProductA1, ProductB1 和 ProductA2, ProductB2。
在 main() 函数中，通过具体的工厂类创建了不同的产品，并调用了它们的 use() 方法。