抽象的工厂方法

什么都不用说,直接贴代码,已运行过。

//抽象的工厂方法

#include "iostream"方法

using namespace std;

class ProductA
{
public:
    virtual void show() = 0;
};

class ProductA1 : public ProductA
{
public:
    void show()
    {
        cout<<"I'm ProductA1" << endl;
    }
};

class ProductA2 : public ProductA
{
public:
    void show()
    {
        cout<<"I'm ProductA2" << endl;
    }
};

class ProductB
{
public:
    virtual void show() = 0;
};

class ProductB1 : public ProductB
{
public:
    void show()
    {
        cout<<"I'm ProductB1" << endl;
    }
};

class ProductB2 : public ProductB
{
public:
    void show()
    {
        cout<<"I'm ProductB2" << endl;
    }
};

//工厂方法
class Factory
{
public:
    virtual ProductA *createProductA() = 0;
    virtual ProductB *createProductB() = 0;    
};

class Factory1 : public Factory
{
public:
    ProductA *createProductA()
    {
        return new ProductA1();
    }

    ProductB *createProductB()
    {
        return new ProductB1();
    }
};

class Factory2 : public Factory
{
public:
    ProductA *createProductA()
    {
        return new ProductA2();
    }

    ProductB *createProductB()
    {
        return new ProductB2();
    }
};

int main(int argc, char const *argv[])
{
    Factory *factoryObj1 = new Factory1();
    ProductA *productObjA1 = factoryObj1->createProductA();
    ProductB *productObjB1 = factoryObj1->createProductB();

    productObjA1->show();
    productObjB1->show();

    Factory *factoryObj2 = new Factory2();
    ProductA *productObjA2 = factoryObj2->createProductA();
    ProductB *productObjB2 = factoryObj2->createProductB();

    productObjA2->show();
    productObjB2->show();


    return 0;
}
  • 1
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
抽象工厂方法模式(Abstract Factory Pattern)是一种创建型设计模式,它提供了一个接口,用于创建一系列相关或依赖对象的家族,而无需指定它们具体的类。 在 C++ 中,抽象工厂方法模式通常通过定义一个抽象基类来实现。这个抽象基类定义了一系列纯虚函数,用于创建不同类型的产品对象。然后,针对不同的产品族,创建具体的工厂类,这些工厂类实现了抽象基类中定义的纯虚函数,用于创建具体的产品对象。 以下是一个简单的抽象工厂方法模式的示例代码: ```c++ // 抽象产品类 A class AbstractProductA { public: virtual void operationA() = 0; }; // 抽象产品类 B class AbstractProductB { public: virtual void operationB() = 0; }; // 具体产品类 A1 class ConcreteProductA1 : public AbstractProductA { public: void operationA() { std::cout << "ConcreteProductA1::operationA()" << std::endl; } }; // 具体产品类 A2 class ConcreteProductA2 : public AbstractProductA { public: void operationA() { std::cout << "ConcreteProductA2::operationA()" << std::endl; } }; // 具体产品类 B1 class ConcreteProductB1 : public AbstractProductB { public: void operationB() { std::cout << "ConcreteProductB1::operationB()" << std::endl; } }; // 具体产品类 B2 class ConcreteProductB2 : public AbstractProductB { public: void operationB() { std::cout << "ConcreteProductB2::operationB()" << std::endl; } }; // 抽象工厂类 class AbstractFactory { public: virtual AbstractProductA* createProductA() = 0; virtual AbstractProductB* createProductB() = 0; }; // 具体工厂类 1 class ConcreteFactory1 : public AbstractFactory { public: AbstractProductA* createProductA() { return new ConcreteProductA1(); } AbstractProductB* createProductB() { return new ConcreteProductB1(); } }; // 具体工厂类 2 class ConcreteFactory2 : public AbstractFactory { public: AbstractProductA* createProductA() { return new ConcreteProductA2(); } AbstractProductB* createProductB() { return new ConcreteProductB2(); } }; int main() { AbstractFactory* factory1 = new ConcreteFactory1(); AbstractProductA* productA1 = factory1->createProductA(); AbstractProductB* productB1 = factory1->createProductB(); productA1->operationA(); // 输出:ConcreteProductA1::operationA() productB1->operationB(); // 输出:ConcreteProductB1::operationB() AbstractFactory* factory2 = new ConcreteFactory2(); AbstractProductA* productA2 = factory2->createProductA(); AbstractProductB* productB2 = factory2->createProductB(); productA2->operationA(); // 输出:ConcreteProductA2::operationA() productB2->operationB(); // 输出:ConcreteProductB2::operationB() return 0; } ``` 在上面的示例代码中,我们定义了两个抽象产品类 `AbstractProductA` 和 `AbstractProductB`,以及四个具体产品类 `ConcreteProductA1`、`ConcreteProductA2`、`ConcreteProductB1` 和 `ConcreteProductB2`。然后,我们定义了一个抽象工厂类 `AbstractFactory`,它包含两个纯虚函数,用于创建不同类型的产品对象。最后,我们定义了两个具体工厂类 `ConcreteFactory1` 和 `ConcreteFactory2`,它们分别实现了 `AbstractFactory` 中定义的纯虚函数,用于创建具体的产品对象。 在 `main` 函数中,我们首先创建了一个 `ConcreteFactory1` 对象,然后使用它创建了一个 `ConcreteProductA1` 和一个 `ConcreteProductB1` 对象,并调用了它们的成员函数。然后,我们创建了一个 `ConcreteFactory2` 对象,使用它创建了一个 `ConcreteProductA2` 和一个 `ConcreteProductB2` 对象,并调用了它们的成员函数。 通过这种方式,我们可以轻松地创建一系列相关或依赖对象的家族,并且无需指定它们具体的类。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值