设计模式——工厂模式

最新推荐文章于 2025-12-01 16:00:40 发布

原创最新推荐文章于 2025-12-01 16:00:40 发布 · 813 阅读

16 ·

CC 4.0 BY-SA版权

文章标签：

#设计模式

简单工厂模式：

工厂模式：

抽象工厂模式：

工厂模式主要有：简单工厂模式、工厂模式、抽象工厂模式；

简单工厂模式：

工厂模式对应的就是一个工厂类。

主要步骤：

创建一个新的类，可以将这个类称之为工厂类。对于简单工厂模式来说，需要的工厂类只有一个
在这个工厂类中添加一个公共的成员函数，通过这个函数来创建我们需要的对象，关于这个函数一般将其称之为工厂函数
关于使用，首先创建一个工厂类对象，然后通过这个对象调用工厂函数，这样就可以生产出一个指定类型的实例对象了。

#include <iostream>
#include <memory>

using namespace std;

// 产品接口类
class Product {
public:
    virtual void use() = 0; // 纯虚函数
    virtual ~Product() = default;
};

// 具体产品A
class ProductA : public Product {
public:
    void use() override {
        cout << "use the product A" << endl;
    }
};

// 具体产品B
class ProductB : public Product {
public:
    void use() override {
        cout << "use the product B" << endl;
    }
};

// 简单工厂类
class Factory {
public:
    static unique_ptr<Product> createProduct(const string& type) {
        if(type == "A") {
            return make_unique<ProductA>();
        } else if(type == "B") {
            return make_unique<ProductB>();
        } else {
            cout << "no such product" << endl;
            return nullptr;
        }
    }
};

// 主函数测试
int main() {
    auto product1 = Factory::createProduct("A");
    product1->use();
    auto product2 = Factory::createProduct("B");
    product2->use();
    auto product3 = Factory::createProduct("C");
    product3->use();

    return 0;

}

从代码中可以看出它是利用一个工厂作为入口，将多个对象的创建和使用分离。它根据传入的参数来创建并返回不同类型的对象实例。

首先是一个产品类接口，应该纯虚函数，方便为下面的具体产品作为一个接口实现；
然后是具体产品类，继承产品类，然后重写产品类中的方法，进行一个具体实现；
最后是实现的简单工厂类，在使用时主要是创建一个工厂类对象，然后通过这个对象调用工厂函数，这样就可以返回出不同类型的对象实例了。

工厂模式：

其实就是在简单工厂模式的基础上对工厂类部分进行了优化；

工厂模式关注的是创建单一类型对象，定义一个抽象方法，由子类实现具体对象的实例化。

工厂方法模式定义了一个创建对象的抽象方法，一个具体的工厂类负责生成一种产品，如果需要添加新的产品，仅需新增对应的具体工厂类而不需要修改原有的代码实现。

#include <iostream>
#include <memory>

using namespace std;

// 产品接口类
class Product {
public:
    virtual void use() = 0; // 纯虚函数
    virtual ~Product() = default;
};

// 具体产品A
class ProductA : public Product {
public:
    void use() override {
        cout << "use the product A" << endl;
    }
};

// 具体产品B
class ProductB : public Product {
public:
    void use() override {
        cout << "use the product B" << endl;
    }
};


// 工厂类-父类
class Factory {
public:
    virtual unique_ptr<Product> createProduct() = 0;
    virtual ~Factory() = default;
};

// 具体工厂A实现
class FactoryA : public Factory {
public:
    unique_ptr<Product> createProduct() override {
        return make_unique<ProductA>();
    }
};

// 具体工厂B实现
class FactoryB : public Factory {
public:
    unique_ptr<Product> createProduct() override {
        return make_unique<ProductB>();
    }
};

// 后续工厂补充...

// 主函数测试
int main() {

    unique_ptr<Factory> factory1 =  make_unique<FactoryA>();
    unique_ptr<Product> product1 = factory1->createProduct();
    product1->use();
    unique_ptr<Factory> factory2 =  make_unique<FactoryB>();
    unique_ptr<Product> product2 = factory2->createProduct();
    product2->use();


    return 0;

}

通过上面代码可以了解到：

工厂模式相对于简单工厂模式的不同就是将工厂类也写成了纯虚函数作为一个接口类的形式，然后再针对具体的产品来继承该工厂类，并重写其方法实现。后续如果再添加产品的话，不需要像简单工厂里一样在工厂类里面进行修改代码，只需要添加该产品的继承工厂类的代码就可。

在方法的调用中，先使用make_unique<FactoryA>()来创建一个FactoryA的实例，并通过unique_ptr<Factory>管理它。

然后通过factory1调用createProduct()来创建一个ProductA实例。其返回一个unique_ptr<Product>。

抽象工厂模式：

抽象工厂关注的是创建一族相关对象，提供一个接口来创建一组相关的或相互依赖的对象，而无需指定它们的具体类。可以说它是生产了一系列产品。

提供一个工厂基类，然后它有很多工厂子类用来区分不同的需求，另外完成这些不同的需求可能还需要一些东西，所以还有几个抽象类，他们也有不同的子类。

#include <iostream>
#include <memory>

// 抽象产品A
class ProductA {
public:
    virtual void use() = 0;
    virtual ~ProductA() = default;
};

// 具体产品A1
class ConcreteProductA1 : public ProductA {
public:
    void use() override {
        std::cout << "Using ConcreteProductA1" << std::endl;
    }
};

// 具体产品A2
class ConcreteProductA2 : public ProductA {
public:
    void use() override {
        std::cout << "Using ConcreteProductA2" << std::endl;
    }
};

// 抽象产品B
class ProductB {
public:
    virtual void eat() = 0;
    virtual ~ProductB() = default;
};

// 具体产品B1
class ConcreteProductB1 : public ProductB {
public:
    void eat() override {
        std::cout << "Eating ConcreteProductB1" << std::endl;
    }
};

// 具体产品B2
class ConcreteProductB2 : public ProductB {
public:
    void eat() override {
        std::cout << "Eating ConcreteProductB2" << std::endl;
    }
};

// 抽象工厂
class AbstractFactory {
public:
    virtual std::unique_ptr<ProductA> createProductA() = 0;
    virtual std::unique_ptr<ProductB> createProductB() = 0;
    virtual ~AbstractFactory() = default;
};

// 具体工厂1
class ConcreteFactory1 : public AbstractFactory {
public:
    std::unique_ptr<ProductA> createProductA() override {
        return std::make_unique<ConcreteProductA1>();
    }

    std::unique_ptr<ProductB> createProductB() override {
        return std::make_unique<ConcreteProductB1>();
    }
};

// 具体工厂2
class ConcreteFactory2 : public AbstractFactory {
public:
    std::unique_ptr<ProductA> createProductA() override {
        return std::make_unique<ConcreteProductA2>();
    }

    std::unique_ptr<ProductB> createProductB() override {
        return std::make_unique<ConcreteProductB2>();
    }
};

// 客户端
int main() {
    std::unique_ptr<AbstractFactory> factory1 = std::make_unique<ConcreteFactory1>();
    auto productA1 = factory1->createProductA();
    auto productB1 = factory1->createProductB();
    productA1->use();
    productB1->eat();

    std::unique_ptr<AbstractFactory> factory2 = std::make_unique<ConcreteFactory2>();
    auto productA2 = factory2->createProductA();
    auto productB2 = factory2->createProductB();
    productA2->use();
    productB2->eat();

    return 0;
}

通过上面代码可以了解到，抽象工厂模式，就是将各个产品也分别进行抽象化，相当于针对一个产品生产了一系列该产品族。

最后调用时同样先生成具体工厂指针实例，然后创建对象调用该具体工厂实例里的createProduct方法来生成具体产品对象进行调用。

抽象工厂模式增加新的产品族较为容易，但是增加新产品类型较为困难。