学习笔记：关注C++设计模式之AbstractFactory模式

关注

原创最新推荐文章于 2026-08-20 14:35:17 发布 742 阅读 AI 写同款· GEO 优化 ›

软考软件设计师案例分析精解：从UML到设计模式的实战避坑指南在软件工程领域，面向对象分析与设计是构建复杂系统的核心思想，其通过UML（统一建模语言）等工具将业务需求转化为可视化的软件蓝图。理解类图、时序图等UML模型背后的设计原理，是确保系统具备良好扩展性和维护性的关键。这一技术价值在于，它能帮助开发者从宏观到微观把握系统结构，有效管理复杂度。在实际应用场景中，无论是企业级应用开发还是系统架构设计，熟练运用设计模式（如策略模式、工厂模式）来解决常见设计问题，已成为高级工程师的必备技能。本文以一次典型的软考真题复盘为切入点，深入剖析了数据流图、ER图与UML类图在复杂阅读详情

#ifndef ABSTRACTFACTORY_H
#define ABSTRACTFACTORY_H

class AbstractProductA;
class AbstractProductB;

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();
    AbstractProductB* CreateProductB();
protected:
private:
};

class ConcreteFactory2:public AbstractFactory
{
public:
    ConcreteFactory2();
    ~ConcreteFactory2();
    AbstractProductA* CreateProductA();
    AbstractProductB* CreateProductB();
protected:
private:
};

#endif // ABSTRACTFACTORY_H

#include "AbstractFactory.h"
#include "Product.h"

using namespace std;

AbstractFactory::AbstractFactory()
{

}
AbstractFactory::~AbstractFactory()
{

}
ConcreteFactory1::ConcreteFactory1()
{

}
ConcreteFactory1::~ConcreteFactory1()
{

}
AbstractProductA* ConcreteFactory1::CreateProductA()
{
    return new ProductA1();
}
AbstractProductB* ConcreteFactory1::CreateProductB()
{
    return new ProductB1();
}
ConcreteFactory2::ConcreteFactory2()
{

}
ConcreteFactory2::~ConcreteFactory2()
{

}
AbstractProductA* ConcreteFactory2::CreateProductA()
{
    return new ProductA2();
}
AbstractProductB* ConcreteFactory2::CreateProductB()
{
    return new ProductB2();
}

#ifndef PRODUCT_H
#define PRODUCT_H

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

class AbstractProductB
{
public:
    virtual ~AbstractProductB();
protected:
    AbstractProductB();
private:
};

class ProductA1:public AbstractProductA
{
public:
    ProductA1();
    ~ProductA1();
protected:
private:
};

class ProductA2:public AbstractProductA
{
public:
    ProductA2();
    ~ProductA2();
protected:
private:
};

class ProductB1:public AbstractProductB
{
public:
    ProductB1();
    ~ProductB1();
protected:
private:
};

class ProductB2:public AbstractProductB
{
public:
    ProductB2();
    ~ProductB2();
protected:
private:
};
#endif // PRODUCT_H

#include "Product.h"
#include <iostream>

using namespace std;

AbstractProductA::AbstractProductA()
{

}
AbstractProductA::~AbstractProductA()
{

}
AbstractProductB::AbstractProductB()
{

}
AbstractProductB::~AbstractProductB()
{

}
ProductA1::ProductA1()
{
    cout << "ProductA1..." << endl;
}
ProductA1::~ProductA1()
{

}
ProductA2::ProductA2()
{
    cout << "ProductA2..." << endl;
}
ProductA2::~ProductA2()
{

}
ProductB1::ProductB1()
{
    cout << "ProductB1..." << endl;
}
ProductB1::~ProductB1()
{

}
ProductB2::ProductB2()
{
    cout << "ProductB2..." << endl;
}
ProductB2::~ProductB2()
{

}

#include "AbstractFactory.h"

int main(int argc, char *argv[])

    AbstractFactory* cf1 = new ConcreteFactory1;

    cf1->CreateProductA();

    cf1->CreateProductB();

    AbstractFactory* cf2 = new ConcreteFactory2;

    cf2->CreateProductA();

    cf2->CreateProductB();

AbstractFactory模式是为创建一组（有多类）相关或依赖的对象提供创建接口，而Factory模式正如我在相应的文档中分析的是为一类对象提供创建接口或延迟对象的创建到子类中实现。并且可以看到，AbstractFactory模式通常都是使用Factory模式实现（ConcreteFactory1）。

它的模型如下：

如果你还看不懂这个模型的用意，那你可以想象一下，一些打怪的游戏，每关都有不同级别的怪物，所以你要为每个关卡生成不同级别的怪物，而如果仍采用Factory模型，因为只有一个工厂生成怪物，因此难以维护。这个模式可以为不同关卡生成不同类型的怪物，当维护的时候，只需要改变各个关卡的怪物类即可。

收录于