C++抽象工厂模式

最新推荐文章于 2024-08-17 15:45:47 发布

橙子砰砰枪

最新推荐文章于 2024-08-17 15:45:47 发布

阅读量418

点赞数 2

分类专栏：设计模式文章标签： c++ 抽象工厂模式开发语言

本文链接：https://blog.csdn.net/NINE_world/article/details/125685652

版权

设计模式专栏收录该内容

11 篇文章 0 订阅

订阅专栏

本文详细介绍了抽象工厂模式，这是一种创建型设计模式，用于创建一系列相关的产品对象。文章通过C++代码展示了如何定义抽象产品类、具体产品类、抽象工厂以及具体工厂，并在主函数中演示了如何使用不同工厂创建和使用产品。

摘要由CSDN通过智能技术生成

/**
    《抽象工厂》 
    抽象工厂模式是一种创建型设计模式， 它能创建一系列相关的对象， 而无需指定其具体类。

    抽象工厂模式建议为系列中的每件产品明确声明接口 （例如椅子、 沙发或咖啡桌）。 
    然后，确保所有产品变体都继承这些接口.
    例如， 所有风格的椅子都实现 椅子接口； 所有风格的咖啡桌都实现 咖啡桌接口， 以此类推。
 */

#include <iostream>
#include <string>

// 抽象产品类
class AbstractProductA
{
public:
    virtual ~AbstractProductA() {}
    virtual std::string UsefulFunctionA() const = 0;
};

// 抽象产品的多种不同实现
class ConcreteProductA1 : public AbstractProductA
{
public:
    std::string UsefulFunctionA() const override
    {
        return "the result of the product A1";
    }
};

class ConcreteProductA2 : public AbstractProductA
{
public:
    std::string UsefulFunctionA() const override
    {
        return "the result of the product A2";
    }
};

// 另一个抽象类产品
class AbstractProductB
{
public:
    virtual ~AbstractProductB() {}
    virtual std::string UsefulFunctionB() const = 0;
    virtual std::string AnotherUsefulFuncitonB(const AbstractProductA &collaborator) const = 0;
};

// 抽象产品的多种不同实现
class ConcreteProductB1 : public AbstractProductB
{
public:
    std::string UsefulFunctionB() const override
    {
        return "the result of the product B1";
    }

    std::string AnotherUsefulFuncitonB(const AbstractProductA &collaborator) const override
    {
        const std::string result = collaborator.UsefulFunctionA();
        return "the reuslt of the B1 collaborator with ( " + result + " )";
    }
};

class ConcreteProductB2 : public AbstractProductB
{
public:
    std::string UsefulFunctionB() const override
    {
        return "the result of the product B2";
    }

    std::string AnotherUsefulFuncitonB(const AbstractProductA &collaborator) const override
    {
        const std::string result = collaborator.UsefulFunctionA();
        return "the result of the B2 collaborator with ( " + result + " )";
    }
};


// 抽象工厂
class AbstractFactory
{
public:
    virtual AbstractProductA *CreateProductA() const = 0;
    virtual AbstractProductB *CreateProductB() const = 0;
};

// 具体的工厂
class ConcreteFactory1 : public AbstractFactory
{
public:
    AbstractProductA* CreateProductA() const override
    {
        return new ConcreteProductA1();
    }

    AbstractProductB* CreateProductB() const override
    {
        return new ConcreteProductB1();
    }
};

class ConcreteFactory2 : public AbstractFactory
{
public:
    AbstractProductA* CreateProductA() const override
    {
        return new ConcreteProductA2();
    }

    AbstractProductB* CreateProductB() const override
    {
        return new ConcreteProductB2();
    }
};


int main()
{
    // 新建一个工厂
    ConcreteFactory1 *factory1 = new ConcreteFactory1();
    // 从这个工厂生产两个产品
    AbstractProductA *product1_a = factory1->CreateProductA();
    AbstractProductB *product1_b = factory1->CreateProductB();
    // 使用产品
    std::cout << product1_a->UsefulFunctionA() << std::endl;
    std::cout << product1_b->UsefulFunctionB() << std::endl;
    std::cout << product1_b->AnotherUsefulFuncitonB(*product1_a) << std::endl;

    std::cout << "----------------" << std::endl;

    // 使用另一个工厂去生产产品
    ConcreteFactory2 *factory2 = new ConcreteFactory2();
    AbstractProductA *product2_a = factory2->CreateProductA();
    AbstractProductB *product2_b = factory2->CreateProductB();
    std::cout << product2_a->UsefulFunctionA() << std::endl;
    std::cout << product2_b->UsefulFunctionB() << std::endl;
    std::cout << product2_b->AnotherUsefulFuncitonB(*product2_a) << std::endl;
}