简单工厂、工厂方法和抽象工厂模式（创建型设计模式）的 C++ 代码示例模板

夜悊2023-11-20 8:05

文章目录

  • 前言
  • 代码仓库
  • [简单工厂模式（Simple Factory）](#简单工厂模式（Simple Factory）)
  • [工厂方法模式（Factory Method）](#工厂方法模式（Factory Method）)
  • [抽象工厂模式（Abstract Factory）](#抽象工厂模式（Abstract Factory）)
  • 总结
  • 参考资料
  • 作者的话

前言

简单工厂、工厂方法和抽象工厂模式（创建型设计模式）的 C++ 代码示例模板。

代码仓库

简单工厂模式（Simple Factory）

结构

  • 抽象产品类
  • 具体产品类 A
  • 具体产品类 B
  • 简单工厂类
  • 简单工厂类的静态方法创建具体产品对象 A 和具体产品对象 B

核心

  • 继承
  • 多态
  • 一个工厂创建多类产品

代码

cpp 复制代码 
#include <iostream>
#include <string>
#include <memory>

using std::cerr;
using std::cout;
using std::endl;
using std::make_unique;
using std::string;
using std::unique_ptr;

// 抽象产品类
class AbstractProduct
{
public:
    AbstractProduct() = default;
    virtual ~AbstractProduct() = default;

    virtual void func() = 0;
};

// 具体产品类 A
class ConcreteProductA : public AbstractProduct
{
public:
    ConcreteProductA() = default;
    ~ConcreteProductA() override = default;

    void func() override
    {
        cout << "ConcreteProductA" << endl;
    }
};

// 具体产品类 B
class ConcreteProductB : public AbstractProduct
{
public:
    ConcreteProductB() = default;
    ~ConcreteProductB() override = default;

    void func() override
    {
        cout << "ConcreteProductB" << endl;
    }
};

// 简单工厂类
class SimpleFactory
{
public:
    // 静态方法依据类型创建不同的具体产品
    static unique_ptr<AbstractProduct> create_concrete_product(const string &concrete_product_type)
    {
        if (concrete_product_type == "A")
        {
            return make_unique<ConcreteProductA>();
        }
        else if (concrete_product_type == "B")
        {
            return make_unique<ConcreteProductB>();
        }
        else
        {
            cerr << "Unknown type of concrete product" << endl;

            return nullptr;
        }
    }
};

// 客户端
int main()
{
    // 使用简单工厂创建不同类型的具体产品
    unique_ptr<AbstractProduct> concrete_product_a = SimpleFactory::create_concrete_product("A"); // 创建具体产品对象 A
    if (concrete_product_a != nullptr)
    {
        concrete_product_a->func();
    }

    unique_ptr<AbstractProduct> concrete_product_b = SimpleFactory::create_concrete_product("B"); // 创建具体产品对象 B
    if (concrete_product_b != nullptr)
    {
        concrete_product_b->func();
    }

    unique_ptr<AbstractProduct> concrete_product_c = SimpleFactory::create_concrete_product("C"); // 创建具体产品对象 C
    if (concrete_product_c != nullptr)
    {
        concrete_product_c->func();
    }

    return 0;
}
/*
输出：
ConcreteProductA
ConcreteProductB
Unknown type of concrete product
*/

工厂方法模式（Factory Method）

结构

  • 抽象产品类
  • 具体产品类 A
  • 具体产品类 B
  • 抽象工厂类
  • 具体工厂类 A
  • 具体工厂类 B
  • 具体工厂对象 A 的方法创建具体产品对象 A
  • 具体工厂对象 B 的方法创建具体产品对象 B

核心

  • 继承
  • 多态
  • 一类工厂创建一类产品

代码

cpp 复制代码 
#include <iostream>
#include <memory>

using std::cout;
using std::endl;
using std::make_unique;
using std::unique_ptr;

// 抽象产品类
class AbstractProduct
{
public:
    AbstractProduct() = default;
    virtual ~AbstractProduct() = default;

    virtual void func() = 0;
};

// 具体产品类 A
class ConcreteProductA : public AbstractProduct
{
public:
    ConcreteProductA() = default;
    ~ConcreteProductA() override = default;

    void func() override
    {
        cout << "ConcreteProductA" << endl;
    }
};

// 具体产品类 B
class ConcreteProductB : public AbstractProduct
{
public:
    ConcreteProductB() = default;
    ~ConcreteProductB() override = default;

    void func() override
    {
        cout << "ConcreteProductB" << endl;
    }
};

// 抽象工厂类
class AbstractFactory
{
public:
    AbstractFactory() = default;
    virtual ~AbstractFactory() = default;

    virtual unique_ptr<AbstractProduct> create_concrete_product() const = 0;
};

// 具体工厂类 A
class ConcreteFactoryA : public AbstractFactory
{
public:
    ConcreteFactoryA() = default;
    ~ConcreteFactoryA() override = default;

    inline unique_ptr<AbstractProduct> create_concrete_product() const override
    {
        return make_unique<ConcreteProductA>();
    }
};

// 具体工厂类 B
class ConcreteFactoryB : public AbstractFactory
{
public:
    ConcreteFactoryB() = default;
    ~ConcreteFactoryB() override = default;

    inline unique_ptr<AbstractProduct> create_concrete_product() const override
    {
        return make_unique<ConcreteProductB>();
    }
};

// 客户端
int main()
{
    // 使用工厂方法创建不同类型的具体产品
    unique_ptr<AbstractFactory> concrete_factory_a = make_unique<ConcreteFactoryA>();               // 创建具体工厂对象 A
    unique_ptr<AbstractProduct> concrete_product_a = concrete_factory_a->create_concrete_product(); // 创建具体产品对象 A
    concrete_product_a->func();

    unique_ptr<AbstractFactory> concrete_factory_b = make_unique<ConcreteFactoryB>();               // 创建具体工厂对象 B
    unique_ptr<AbstractProduct> concrete_product_b = concrete_factory_b->create_concrete_product(); // 创建具体产品对象 B
    concrete_product_b->func();

    return 0;
}
/*
输出：
ConcreteProductA
ConcreteProductB
*/

抽象工厂模式（Abstract Factory）

结构

  • 抽象产品类 A
  • 具体产品类 A1
  • 具体产品类 B1
  • 抽象产品类 B
  • 具体产品类 B1
  • 具体产品类 B2
  • 抽象工厂类1
  • 具体工厂类1
  • 抽象工厂类2
  • 具体工厂类2
  • 具体工厂对象1 的方法创建具体产品对象 A1 和 具体产品对象 B1
  • 具体工厂对象2 的方法创建具体产品对象 A2 和 具体产品对象 B2

核心

  • 继承
  • 多态
  • 产品和工厂形成二维结构：工厂1创建产品 A1 和 B1，工厂2创建产品 A2 和 B2

代码

cpp 复制代码 
#include <iostream>
#include <memory>

using std::cout;
using std::endl;
using std::make_unique;
using std::unique_ptr;

// 抽象产品类 A
class AbstractProductA
{
public:
    AbstractProductA() = default;
    virtual ~AbstractProductA() = default;

    virtual void func() = 0;
};

// 具体产品类 A1
class ConcreteProductA1 : public AbstractProductA
{
public:
    ConcreteProductA1() = default;
    ~ConcreteProductA1() override = default;

    void func() override
    {
        cout << "ConcreteProductA1" << endl;
    }
};

// 具体产品类 A2
class ConcreteProductA2 : public AbstractProductA
{
public:
    ConcreteProductA2() = default;
    ~ConcreteProductA2() override = default;

    void func() override
    {
        cout << "ConcreteProductA2" << endl;
    }
};

// 抽象产品类 B
class AbstractProductB
{
public:
    AbstractProductB() = default;
    virtual ~AbstractProductB() = default;

    virtual void func() = 0;
};

// 具体产品类 B1
class ConcreteProductB1 : public AbstractProductB
{
public:
    ConcreteProductB1() = default;
    ~ConcreteProductB1() override = default;

    void func() override
    {
        cout << "ConcreteProductB1" << endl;
    }
};

// 具体产品类 B2
class ConcreteProductB2 : public AbstractProductB
{
public:
    ConcreteProductB2() = default;
    ~ConcreteProductB2() override = default;

    void func() override
    {
        cout << "ConcreteProductB2" << endl;
    }
};

// 抽象工厂类
class AbstractFactory
{
public:
    AbstractFactory() = default;
    virtual ~AbstractFactory() = default;

    virtual unique_ptr<AbstractProductA> create_product_a() const = 0;
    virtual unique_ptr<AbstractProductB> create_product_b() const = 0;
};

// 具体工厂类 1
class ConcreteFactory1 : public AbstractFactory
{
public:
    ConcreteFactory1() = default;
    virtual ~ConcreteFactory1() = default;

    inline unique_ptr<AbstractProductA> create_product_a() const override
    {
        return make_unique<ConcreteProductA1>();
    }

    inline unique_ptr<AbstractProductB> create_product_b() const override
    {
        return make_unique<ConcreteProductB1>();
    }
};

// 具体工厂类 2
class ConcreteFactory2 : public AbstractFactory
{
public:
    ConcreteFactory2() = default;
    virtual ~ConcreteFactory2() = default;

    inline unique_ptr<AbstractProductA> create_product_a() const override
    {
        return make_unique<ConcreteProductA2>();
    }

    inline unique_ptr<AbstractProductB> create_product_b() const override
    {
        return make_unique<ConcreteProductB2>();
    }
};

// 客户端
int main()
{
    // 使用抽象工厂创建不同类型的具体产品
    unique_ptr<AbstractFactory> concrete_factory_1 = make_unique<ConcreteFactory1>();          // 创建具体工厂对象1
    unique_ptr<AbstractProductA> concrete_product_a1 = concrete_factory_1->create_product_a(); // 创建具体产品对象 A1
    unique_ptr<AbstractProductB> concrete_product_b1 = concrete_factory_1->create_product_b(); // 创建具体产品对象 B1
    concrete_product_a1->func();
    concrete_product_b1->func();

    unique_ptr<AbstractFactory> concrete_factory_2 = make_unique<ConcreteFactory2>();          // 创建具体工厂2
    unique_ptr<AbstractProductA> concrete_product_a2 = concrete_factory_2->create_product_a(); // 创建具体产品对象 B1
    unique_ptr<AbstractProductB> concrete_product_b2 = concrete_factory_2->create_product_b(); // 创建具体产品对象 B1
    concrete_product_a2->func();
    concrete_product_b2->func();

    return 0;
}
/*
输出：
ConcreteProductA1
ConcreteProductB1
ConcreteProductA2
ConcreteProductB2
*/

总结

简单工厂、工厂方法和抽象工厂模式（创建型设计模式）的 C++ 代码示例模板。

参考资料

作者的话

  • 感谢参考资料的作者/博主
  • 作者：夜悊
  • 版权所有，转载请注明出处，谢谢~
  • 如果文章对你有帮助，请点个赞或加个粉丝吧，你的支持就是作者的动力~
  • 文章在描述时有疑惑的地方，请留言，定会一一耐心讨论、解答
  • 文章在认识上有错误的地方, 敬请批评指正
  • 望读者们都能有所收获
相关推荐
ULTRA??21 分钟前
C加加中的结构化绑定（解包，折叠展开）
开发语言·c++
凌云行者1 小时前
OpenGL入门005——使用Shader类管理着色器
c++·cmake·opengl
凌云行者1 小时前
OpenGL入门006——着色器在纹理混合中的应用
c++·cmake·opengl
～yY…s<#>1 小时前
【刷题17】最小栈、栈的压入弹出、逆波兰表达式
c语言·数据结构·c++·算法·leetcode
可均可可2 小时前
C++之OpenCV入门到提高004：Mat 对象的使用
c++·opencv·mat·imread·imwrite
白子寰2 小时前
【C++打怪之路Lv14】- “多态“篇
开发语言·c++
小芒果_013 小时前
P11229 [CSP-J 2024] 小木棍
c++·算法·信息学奥赛
gkdpjj3 小时前
C++优选算法十 哈希表
c++·算法·散列表
王俊山IT3 小时前
C++学习笔记----10、模块、头文件及各种主题（一）---- 模块（5）
开发语言·c++·笔记·学习
-Even-3 小时前
【第六章】分支语句和逻辑运算符
c++·c++ primer plus
热门推荐
01【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总02(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04【AIGC】重塑未来的科技巨轮05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06【经验分享】Ubuntu22.04安装微信(linux官方版)07基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测08Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO09RAG 实践- Ollama+RagFlow 部署本地知识库10【TC3xx芯片】TC3xx芯片电源管理系统PMS详解