设计模式 工厂模式

简单工厂模式简介

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

简单工厂模式结构

工厂类（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() 
{
    // 创建工厂 A
    std::unique_ptr<Factory> factoryA = std::make_unique<ConcreteFactoryA>();
    // 使用工厂 A 创建产品 A
    std::unique_ptr<Product> productA = factoryA->createProduct();
    productA->operation();

    // 创建工厂 B
    std::unique_ptr<Factory> factoryB = std::make_unique<ConcreteFactoryB>();
    // 使用工厂 B 创建产品 B
    std::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;
}