C++几种工厂模式和实现实例

洛克希德马丁

已于 2024-10-13 17:07:01 修改

阅读量805

点赞数 5

分类专栏： C++ 文章标签： c++ java 算法设计模式

于 2024-10-13 17:06:44 首次发布

本文链接：https://blog.youkuaiyun.com/jiexijihe945/article/details/142900471

版权

C++ 专栏收录该内容

62 篇文章

订阅专栏

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

前言
一、什么是工厂模式
二、介绍
使用场景
总结

前言

常写C++代码的人一定对于工厂模式不陌生，今天这篇文章就介绍下几种常见的工厂模式并说明使用场景

一、什么是工厂模式

简而言之，工厂模式是一种设计模式，是对开闭原则编程的一种展现。

二、介绍

所有的示例代码基于C++17版本，如果你用了C++11，就会报错，C++11没有std::make_unique这个方法（在memory头文件里）。

1.简单工厂

#include <iostream>
#include <memory>

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

        virtual ~Product() = default;
    };

    class ProductA : public Product {
    public:
        void show() override {
            std::cout << "ProductA" << std::endl;
        }
    };

    class ProductB : public Product {
    public:
        void show() override {
            std::cout << "ProductB" << std::endl;
        }
    };

    class Factory {
    public:
        static std::unique_ptr<Product> createProduct(char type) {
            switch (type) {
                case 'A':
                    return std::make_unique<ProductA>();
                case 'B':
                    return std::make_unique<ProductB>();
                default:
                    return nullptr;
            }
        }
    };

main.cpp

#include "Factory.h"

int main(){
	
	auto produce1 = Factory::createProduct('A');
    produce1->show();
    auto produce2 = Factory::createProduct('B');
    produce2->show();
	return 0;
}

特点：简单工厂模式定义了一个工厂类，通过工厂类的静态方法来创建不同的对象
优点：使用者只需要知道工厂类的名称和参数，不需要了解具体的构造过程
缺点：增加新产品时需要修改工厂类，违反了开闭原则（对扩展开放，对修改关闭）

2.工厂方法模式

Factory.h

#include <iostream>
#include <memory>
   
class Product {
    public:
        virtual void show() = 0;

        virtual ~Product() = default;
    };

    class ProductA : public Product {
    public:
        void show() override {
            std::cout << "ProductA" << std::endl;
        }
    };

    class ProductB : public Product {
    public:
        void show() override {
            std::cout << "ProductB" << std::endl;
        }
    };

    class Factory {
    public:
        virtual std::unique_ptr<Product> createProduct() = 0;

        virtual ~Factory() = default;
    };

    class FactoryA : public Factory {
    public:
        std::unique_ptr<Product> createProduct() override {
            return std::make_unique<ProductA>();
        }
    };

    class FactoryB : public Factory {
    public:
        std::unique_ptr<Product> createProduct() override {
            return std::make_unique<ProductB>();
        }
    };

main.cpp

#include "Factory.h"

int main(){
	auto factoryA = std::make_unique<FactoryA>();
    auto productA = factoryA->createProduct();
    productA->show();

    auto factoryB = std::make_unique<FactoryB>();
    auto productB = factoryB->createProduct();
    productB->show();
	return 0;
}

特点：工厂方法模式将对象的创建延迟到子类中，每一个具体产品对应一个具体工厂
优点：增加新产品时，只需增加一个具体工厂类，不需要修改工厂类，符合开闭原则
缺点：类的数量增加，使得系统更加复杂

3.抽象工厂

Factory.h

#include <iostream>
#include <memory>

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

        virtual ~AbstractProductA() = default;
    };

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

        virtual ~AbstractProductB() = default;
    };

    class ProductA1 : public AbstractProductA {
    public:
        void show() override {
            std::cout << "ProductA1" << std::endl;
        }
    };

    class ProductA2 : public AbstractProductA {
    public:
        void show() override {
            std::cout << "ProductA2" << std::endl;
        }
    };

    class ProductB1 : public AbstractProductB {
    public:
        void show() override {
            std::cout << "ProductB1" << std::endl;
        }
    };

    class ProductB2 : public AbstractProductB {
    public:
        void show() override {
            std::cout << "ProductB2" << std::endl;
        }
    };

    class AbstractFactory {
    public:
        virtual std::unique_ptr<AbstractProductA> createProductA() = 0;

        virtual std::unique_ptr<AbstractProductB> createProductB() = 0;

        virtual ~AbstractFactory() = default;
    };

    class Factory1 : public AbstractFactory {
    public:
        std::unique_ptr<AbstractProductA> createProductA() override {
            return std::make_unique<ProductA1>();
        }

        std::unique_ptr<AbstractProductB> createProductB() override {
            return std::make_unique<ProductB1>();
        }
    };

    class Factory2 : public AbstractFactory {
    public:
        std::unique_ptr<AbstractProductA> createProductA() override {
            return std::make_unique<ProductA2>();
        }

        std::unique_ptr<AbstractProductB> createProductB() override {
            return std::make_unique<ProductB2>();
        }
    };

main.cpp

#include "Factory.h"

int main(){

	auto factory1 = std::make_unique<Factory1>();
    auto productA1 = factory1->createProductA();
    auto productB1 = factory1->createProductB();
    productA1->show();
    productB1->show();

    auto factory2 = std::make_unique<Factory2>();
    auto productA2 = factory2->createProductA();
    auto productB2 = factory2->createProductB();
    productA2->show();
    productB2->show();
	return 0;
}