简单工厂模式简介

简单工厂模式通过一个专门的工厂类来负责对象的创建，客户端只需要提供工厂类需要的参数，然后工厂类就会根据这些参数来创建相应的对象，客户无需了解对象创建的逻辑。

简单工厂模式结构

工厂类（Factory）：负责创建对象的类。它包含一个方法，根据客户端传递的参数来决定创建哪种类型的对象。

产品类（Product）：被创建的对象的抽象类或接口。它定义了对象的基本属性和行为，具体的产品类将实现这些抽象方法。

具体产品类（Concrete Product）：实现了产品类的具体子类。它是工厂类创建的对象的实际类型。

枚举：用于规范传参种类，可以不写。

简单工厂模式实现

#include <iostream>
#include <string>// 产品类 - 抽象类或接口
class Product 
{
public:virtual void use() = 0;
};// 具体产品类A
class ConcreteProductA : public Product 
{
public:void use() override {std::cout << "使用A产品" << std::endl;}
};// 具体产品类B
class ConcreteProductB : public Product 
{
public:void use() override {std::cout << "使用B产品" << std::endl;}
};// 工厂类
class Factory 
{
public:// 根据类型创建产品static Product* createProduct(const std::string& type) {// 也可用case语句--效率更高if (type == "A") {return new ConcreteProductA();} else if (type == "B") {return new ConcreteProductB();} else {return nullptr; // 可以考虑抛出异常或返回默认产品}}
};int main() 
{// 使用工厂创建产品Product* productA = Factory::createProduct("A");if (productA) {productA->use();delete productA;}Product* productB = Factory::createProduct("B");if (productB) {productB->use();delete productB;}return 0;
}

工厂模式简介

在简单工厂模式的基础上进行了优化，从简单工厂模式的类图或代码中可以看出，如果程序设计者想设计新的产品，就要在工厂类中增加新的代码，这样如果更新产品较多就会造成工厂类代码长度过长，且因为要修改已有的代码，开发封闭原则实现程度较低（绝对的开放封闭不存在）。 使用工厂模式则可以解决这些问题。

工厂模式结构

抽象工厂（Abstract Factory）：定义了创建产品对象的接口。

具体工厂（Concrete Factory）：实现了抽象工厂接口，负责创建具体的产品对象。

抽象产品（Abstract Product）：定义了产品的基本属性和行为。

具体产品（Concrete Product）：实现了抽象产品接口，是具体的产品对象。

每种具体工厂对应一个具体产品。

工厂模式实现

#include <iostream>
#include <memory>// 抽象产品
class Product 
{
public:virtual void operation() = 0;virtual ~Product() {}
};// 具体产品 A
class ConcreteProductA : public Product 
{
public:void operation() override {std::cout << "具体产品 A 的操作" << endl ;}
};// 具体产品 B
class ConcreteProductB : public Product 
{
public:void operation() override {std::cout << "具体产品 B 的操作" << endl;}
};// 抽象工厂
class Factory 
{
public:virtual std::unique_ptr<Product> createProduct() = 0;virtual ~Factory() {}
};// 具体工厂 A
class ConcreteFactoryA : public Factory {
public:std::unique_ptr<Product> createProduct() override {return std::make_unique<ConcreteProductA>();}
};// 具体工厂 B
class ConcreteFactoryB : public Factory 
{
public:std::unique_ptr<Product> createProduct() override {return std::make_unique<ConcreteProductB>();}
};int main() 
{// 创建工厂 Astd::unique_ptr<Factory> factoryA = std::make_unique<ConcreteFactoryA>();// 使用工厂 A 创建产品 Astd::unique_ptr<Product> productA = factoryA->createProduct();productA->operation();// 创建工厂 Bstd::unique_ptr<Factory> factoryB = std::make_unique<ConcreteFactoryB>();// 使用工厂 B 创建产品 Bstd::unique_ptr<Product> productB = factoryB->createProduct();productB->operation();delete factoryA ;delete productA ;delete factoryB ;delete productB ; return 0;
}

抽象工厂模式简介

和工厂模式结构类似，只不过多做了一层虚拟接口类。抽象工厂和工厂的区别在于选择使用上：
工厂模式使用情境：
1当一个类不知道它所必须创建的对象的类的时候
2当一个类希望由它的子类来指定它所创建的对象的时候
3当类将创建对象的职责委托给多个帮助子类中的某一个，并且你望将哪一个帮助子类是代理者这一信息局部化的时候,
抽象工厂模式使用情境：
1当需要创建的对象是一系列相互关联或相互依赖的产品族的时候
2当系统需要独立于它的产品的创建、组合和表示的时候。
3当一个系统要由多个产品系列中的一个来配置时。

抽象工厂模式结构

抽象工厂(图中 工厂接口类): 这是工厂模式的核心,它定义了一个创建一组产品的接口。

具体工厂(图中 具体工厂): 实现了抽象工厂接口,生产一组具体的产品。

抽象产品(图中 产品–接口类): 定义了一个产品对象的接口。

具体产品(图中 部件A1A2…C2C3): 实现了抽象产品接口,是具体工厂创建的具体对象。

抽象工厂模式实现

// 抽象产品A
class AbstractProductA 
{
public:virtual std::string Operation() const = 0;
};// 具体产品A1
class ConcreteProductA1 : public AbstractProductA 
{
public:std::string Operation() const override {return "ConcreteProductA1";}
};// 具体产品A2
class ConcreteProductA2 : public AbstractProductA 
{
public:std::string Operation() const override {return "ConcreteProductA2";}
};// 抽象产品B
class AbstractProductB 
{
public:virtual std::string OperationB() const = 0;
};// 具体产品B1
class ConcreteProductB1 : public AbstractProductB 
{
public:std::string OperationB() const override{return "ConcreteProductB1";}
};// 具体产品B2
class ConcreteProductB2 : public AbstractProductB 
{
public:std::string OperationB() const override {return "ConcreteProductB2";}
};// 抽象工厂
class AbstractFactory 
{
public:virtual AbstractProductA* CreateProductA() const = 0;virtual AbstractProductB* CreateProductB() const = 0;
};// 具体工厂1
class ConcreteFactory1 : public AbstractFactory 
{
public:AbstractProductA* CreateProductA() const override{return new ConcreteProductA1();}AbstractProductB* CreateProductB() const override {return new ConcreteProductB1();}
};// 具体工厂2
class ConcreteFactory2 : public AbstractFactory 
{
public:AbstractProductA* CreateProductA() const override {return new ConcreteProductA2();}AbstractProductB* CreateProductB() const override {return new ConcreteProductB2();}
};// 客户端代码
void ClientCode(const AbstractFactory& factory) 
{const auto product_a = factory.CreateProductA();const auto product_b = factory.CreateProductB();std::cout << product_a->Operation() << "\n";std::cout << product_b->OperationB() << "\n";delete product_a;delete product_b;
}int main() 
{std::cout << "Client: Testing client code with the first factory type:\n";ConcreteFactory1 factory1;ClientCode(factory1);std::cout << "\n";std::cout << "Client: Testing the same client code with the second factory type:\n";ConcreteFactory2 factory2;ClientCode(factory2);return 0;
}