C++抽象工厂模式

#include 
#include 

// 抽象产品类
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;
}