工厂模式与抽象工厂模式的异同

设计模式是软件设计中常用的方法论，用于解决特定场景下的设计问题。本文将详细讨论工厂模式（Factory Method）和抽象工厂模式（Abstract Factory）的异同，并给出相应的C++代码示例。

工厂模式

工厂模式是一种创建型设计模式，它定义了一个用于创建对象的接口，但由子类决定实例化哪一个类。工厂方法让类的实例化推迟到子类。

示例代码：

假设我们有一个产品层次结构，其中包括不同类型的汽车（如汽油车和电动车）。以下是工厂模式的实现：
 

#include <iostream>
#include <memory>

// 产品接口
class Car {
public:
    virtual void drive() = 0;
    virtual ~Car() = default;
};

// 具体产品类：汽油车
class GasolineCar : public Car {
public:
    void drive() override {
        std::cout << "Driving a gasoline car!" << std::endl;
    }
};

// 具体产品类：电动车
class ElectricCar : public Car {
public:
    void drive() override {
        std::cout << "Driving an electric car!" << std::endl;
    }
};

// 工厂基类
class CarFactory {
public:
    virtual std::unique_ptr<Car> createCar() = 0;
    virtual ~CarFactory() = default;
};

// 具体工厂类：生产汽油车的工厂
class GasolineCarFactory : public CarFactory {
public:
    std::unique_ptr<Car> createCar() override {
        return std::make_unique<GasolineCar>();
    }
};

// 具体工厂类：生产电动车的工厂
class ElectricCarFactory : public CarFactory {
public:
    std::unique_ptr<Car> createCar() override {
        return std::make_unique<ElectricCar>();
    }
};

// 客户端代码
int main() {
    std::unique_ptr<CarFactory> factory = std::make_unique<GasolineCarFactory>();
    std::unique_ptr<Car> car = factory->createCar();
    car->drive();

    factory = std::make_unique<ElectricCarFactory>();
    car = factory->createCar();
    car->drive();

    return 0;
}

在这个例子中，`CarFactory`是工厂基类，`GasolineCarFactory`和`ElectricCarFactory`是具体工厂类，它们分别创建`GasolineCar`和`ElectricCar`对象。

抽象工厂模式

抽象工厂模式也是一种创建型设计模式，它提供一个接口，用于创建相关或依赖对象的家族，而无需明确指定具体类。它的目标是为一系列相关或相互依赖的对象提供一个接口。

示例代码

假设我们有一个产品层次结构，其中包括不同类型的汽车和对应的引擎。以下是抽象工厂模式的实现：
 

#include <iostream>
#include <memory>

// 汽车产品接口
class Car {
public:
    virtual void drive() = 0;
    virtual ~Car() = default;
};

// 引擎产品接口
class Engine {
public:
    virtual void start() = 0;
    virtual ~Engine() = default;
};

// 具体产品类：汽油车
class GasolineCar : public Car {
public:
    void drive() override {
        std::cout << "Driving a gasoline car!" << std::endl;
    }
};

// 具体产品类：电动车
class ElectricCar : public Car {
public:
    void drive() override {
        std::cout << "Driving an electric car!" << std::endl;
    }
};

// 具体产品类：汽油引擎
class GasolineEngine : public Engine {
public:
    void start() override {
        std::cout << "Starting a gasoline engine!" << std::endl;
    }
};

// 具体产品类：电动引擎
class ElectricEngine : public Engine {
public:
    void start() override {
        std::cout << "Starting an electric engine!" << std::endl;
    }
};

// 抽象工厂基类
class CarFactory {
public:
    virtual std::unique_ptr<Car> createCar() = 0;
    virtual std::unique_ptr<Engine> createEngine() = 0;
    virtual ~CarFactory() = default;
};

// 具体工厂类：生产汽油车及其引擎的工厂
class GasolineCarFactory : public CarFactory {
public:
    std::unique_ptr<Car> createCar() override {
        return std::make_unique<GasolineCar>();
    }
    std::unique_ptr<Engine> createEngine() override {
        return std::make_unique<GasolineEngine>();
    }
};

// 具体工厂类：生产电动车及其引擎的工厂
class ElectricCarFactory : public CarFactory {
public:
    std::unique_ptr<Car> createCar() override {
        return std::make_unique<ElectricCar>();
    }
    std::unique_ptr<Engine> createEngine() override {
        return std::make_unique<ElectricEngine>();
    }
};

// 客户端代码
int main() {
    std::unique_ptr<CarFactory> factory = std::make_unique<GasolineCarFactory>();
    std::unique_ptr<Car> car = factory->createCar();
    std::unique_ptr<Engine> engine = factory->createEngine();
    car->drive();
    engine->start();

    factory = std::make_unique<ElectricCarFactory>();
    car = factory->createCar();
    engine = factory->createEngine();
    car->drive();
    engine->start();

    return 0;
}

在这个例子中，`CarFactory`是抽象工厂基类，`GasolineCarFactory`和`ElectricCarFactory`是具体工厂类，它们分别创建相关联的`GasolineCar`、`ElectricCar`和对应的`GasolineEngine`、`ElectricEngine`对象。

工厂模式与抽象工厂模式的比较

相似点

1. 创建型模式：两者都是用于对象创建的设计模式。
2. 解耦对象创建：两者都通过将对象的创建过程封装在工厂类中，来解耦对象的创建和使用。

不同点

1. 关注点不同：
   - 工厂模式关注单一产品对象的创建。
   - 抽象工厂模式关注一系列相关或相互依赖的产品对象的创建。

2. 复杂度：
   - 工厂模式相对简单，只涉及单一产品的创建。
   - 抽象工厂模式较复杂，因为它需要创建多个相关的产品对象。

3. 扩展性：
   - 工厂模式扩展单一产品时较为简单。
   - 抽象工厂模式在需要扩展产品家族时提供更好的支持，但相对更复杂。

结论

工厂模式和抽象工厂模式是设计模式中的两个重要创建型模式。工厂模式适用于创建单一对象，而抽象工厂模式适用于创建相关联的一组对象。在实际应用中，应根据需求选择合适的设计模式，以达到代码的高内聚和低耦合。

与其他模式的关系：

• 在许多设计工作的初期都会使用工厂方法模式 （较为简单， 而且可以更方便地通过子类进行定制）， 随后演化为使用抽象工厂模式、 原型模式或生成器模式 （更灵活但更加复杂）。

• 生成器重点关注如何分步生成复杂对象。 抽象工厂专门用于生产一系列相关对象。 抽象工厂会马上返回产品， 生成器则允许你在获取产品前执行一些额外构造步骤。

• 抽象工厂模式通常基于一组工厂方法， 但你也可以使用原型模式来生成这些类的方法。

• 当只需对客户端代码隐藏子系统创建对象的方式时， 你可以使用抽象工厂来代替外观模式。

• 你可以将抽象工厂和桥接模式搭配使用。 如果由桥接定义的抽象只能与特定实现合作， 这一模式搭配就非常有用。 在这种情况下， 抽象工厂可以对这些关系进行封装， 并且对客户端代码隐藏其复杂性。

• 抽象工厂、 生成器和原型都可以用单例模式来实现。