工厂模式是一种创建型设计模式,它提供了一种创建对象的方式,而无需指定具体的类。工厂模式通过定义一个创建对象的接口,让子类决定实例化哪一个类。工厂模式可以分为简单工厂模式、工厂方法模式和抽象工厂模式。
下面是一个使用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() {// 使用工厂创建产品Astd::unique_ptr<Product> productA = Factory::createProduct("A");if (productA) {productA->use();}// 使用工厂创建产品Bstd::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创建产品Astd::unique_ptr<Factory> factoryA = std::make_unique<FactoryA>();std::unique_ptr<Product> productA = factoryA->createProduct();productA->use();// 使用工厂B创建产品Bstd::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和B1std::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和B2std::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()
方法。
这些示例展示了如何使用C++实现工厂模式的三种变体:简单工厂模式、工厂方法模式和抽象工厂模式。每种模式都有其适用的场景,选择哪种模式取决于具体的需求和设计目标。