设计模式-抽象工厂_抽象工厂期末大题-优快云博客

本文链接：https://blog.youkuaiyun.com/Go_bro/article/details/122291305

本文详细介绍了抽象工厂模式，包括其定义、应用场景及优缺点。通过代码示例展示了如何创建产品族和产品等级，并指出该模式适用于扩展同一产品等级，但扩展产品族时存在困难。在实际应用中，抽象工厂模式能够确保客户端使用同一产品族的对象，但可能增加系统的复杂性和理解成本。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

设计模式-抽象工厂

产品族：一个品牌下面的所有产品；

产品等级：多个品牌下面的同种产品；

应用场景

抽象工厂后续的拓展是拓展产品等级，如果是拓展产品族则不建议使用抽象工厂模式

类图

在这里插入图片描述

代码

#include <iostream> 
using namespace std; 


class AbstractProductA 
{ 
public: 
    virtual ~AbstractProductA(){}; 
protected: 
    AbstractProductA(){

    }
}; 

class ProductA1:public AbstractProductA 
{ 
public: 
    ProductA1(){
        cout<<"ProductA1"<<endl;
    }
    ~ProductA1(){} 
}; 
class ProductA2:public AbstractProductA 
{ 
public: 
    ProductA2(){
        cout<<"ProductA2"<<endl;
    }
    ~ProductA2(){} 
};

//后续拓展ProductA3
class ProductA3:public AbstractProductA 
{ 
public: 
    ProductA3(){
        cout<<"ProductA3"<<endl;
    }
    ~ProductA3(){} 
}; 
class AbstractProductB 
{ 
public: 
    virtual ~AbstractProductB(){}; 
protected: 
    AbstractProductB(){}
};


class ProductB1:public AbstractProductB 
{ 
public: 
    ProductB1(){
        cout<<"ProductB1"<<endl;
    }
    ~ProductB1(){} 
}; 
class ProductB2:public AbstractProductB 
{ 
public: 
    ProductB2(){
        cout<<"ProductB2"<<endl;
    }
    ~ProductB2(){}; 
};

//后续拓展ProductB3
class ProductB3:public AbstractProductB 
{ 
public: 
    ProductB3(){
        cout<<"ProductB3"<<endl;
    }
    ~ProductB3(){}; 
};
class AbstractFactory 
{ 
public: 
    virtual ~AbstractFactory(){}; 
    virtual AbstractProductA* CreateProductA() = 0;
virtual AbstractProductB* CreateProductB() = 0;
protected: 
    AbstractFactory(){}
private: 
}; 
class ConcreteFactory1:public AbstractFactory
{ 
public: 
    ConcreteFactory1(){}
    ~ConcreteFactory1(){} 
    AbstractProductA* CreateProductA(){
        return new ProductA1;
    }
    AbstractProductB* CreateProductB(){
        return new ProductB1;
    }

};

class ConcreteFactory2:public AbstractFactory
{ 
public: 
 ConcreteFactory2(){}
 ~ConcreteFactory2(){} 
 AbstractProductA* CreateProductA(){
    return new ProductA2;
 }
 AbstractProductB* CreateProductB(){
    return new ProductB2;
}
};
//后续拓展ConcreteFactory3
class ConcreteFactory3:public AbstractFactory
{ 
public: 
 ConcreteFactory3(){}
 ~ConcreteFactory3(){} 
 AbstractProductA* CreateProductA(){
    return new ProductA3;
 }
 AbstractProductB* CreateProductB(){
    return new ProductB3;
}
};
int main(int argc,char* argv[])
{ 
    AbstractFactory* cf1 = new ConcreteFactory1(); 
    cf1->CreateProductA(); 
    cf1->CreateProductB(); 


    AbstractFactory* cf2 = new ConcreteFactory2(); 
    cf2->CreateProductA(); 
    cf2->CreateProductB(); 
    //后续拓展
    AbstractFactory* cf3 = new ConcreteFactory3(); 
    cf3->CreateProductA(); 
    cf3->CreateProductB(); 
    return 0;
}