C++ - 工厂模式

前言

常写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;
    };

// 具体产品类A
    class ProductA : public Product {
    public:
        void show() override {
            std::cout << "ProductA" << std::endl;
        }
    };
// 具体产品类B
    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;
    };

// 具体产品类 A 和 B
    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;
    };
// 具体工厂 A 和 B，分别创建 A 和 B 产品类型
    class FactoryA : public Factory {
    public:
        std::unique_ptr<Product> createProduct() override {// 实现具体的工厂方法以创建产品 B。
            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>();// 使用具体工厂 A 创建产品 A。
    auto productA = factoryA->createProduct();// 通过工厂方法创建产品 A 的实例。
    productA->show();// 使用产品 A。输出

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

执行结果：

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

3.抽象工厂

Factory.h

#include <iostream>
#include <memory>

//抽象的产品A
class AbstractProductA {
public:
    virtual void show() = 0;

    virtual ~AbstractProductA() = default;
};
//抽象的产品B
class AbstractProductB {
public:
    virtual void show() = 0;

    virtual ~AbstractProductB() = default;
};
//产品A1
class ProductA1 : public AbstractProductA {
public:
    void show() override {
        std::cout << "ProductA1" << std::endl;
    }
};
//产品A2
class ProductA2 : public AbstractProductA {
public:
    void show() override {
        std::cout << "ProductA2" << std::endl;
    }
};
//产品B1
class ProductB1 : public AbstractProductB {
public:
    void show() override {
        std::cout << "ProductB1" << std::endl;
    }
};
//产品B2
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;
};
//工厂1
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>();
    }
};
//工厂2
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;
}