C++设计模式---工厂模式

        C++中工厂模式是一种创建型设计模式，它允许客户端代码通过调用工厂方法来创建对象，而无需直接使用new运算符实例化具体类。这种模式有助于将类的创建与使用相分离，并且在需要添加新的具体类时可以减少对客户端代码的影响。

        工厂模式通常有两种实现方式：简单工厂模式和抽象工厂模式。简单工厂模式是最基本的工厂模式，它通过一个静态方法来创建具体的对象。而抽象工厂模式则通过一个抽象工厂类来定义一组创建相关对象的方法，每个具体工厂类实现这些方法来创建特定的对象。

1、简单工厂模式

        简单工厂模式是最基本的工厂模式，它通过一个静态方法来创建具体的对象。

#include <iostream>  
#include <string>  
  
// 定义产品接口  【抽象类】
class Product {  
public:  
    virtual ~Product() {}  
    virtual void use() const = 0;  // 纯虚函数必须被子类重写
};  
  
// 定义具体产品类  
class ProductA : public Product {  
public:  
    void use() const override {  
        std::cout << "Using ProductA" << std::endl;  
    }  
};  
  
class ProductB : public Product {  
public:  
    void use() const override {  
        std::cout << "Using ProductB" << std::endl;  
    }  
};  
  
// 定义简单工厂类  
class SimpleFactory {  
public:  
    static Product* createProduct(const std::string& type) {  
        if (type == "A") {  
            return new ProductA();  
        } else if (type == "B") {  
            return new ProductB();  
        } else {  
            return nullptr;  
        }  
    }  
};  
  
// 客户端代码  
int main() {  
    Product* productA = SimpleFactory::createProduct("A");  
    if (productA) {  
        productA->use();  
        delete productA; // 释放内存  
    }  
  
    Product* productB = SimpleFactory::createProduct("B");  
    if (productB) {  
        productB->use();  
        delete productB; // 释放内存  
    }   
    return 0;  
}

结果：

Using ProductA
Using ProductB

2、抽象工厂模式

        抽象工厂模式则通过一个抽象工厂类来定义一组创建相关对象的方法，每个具体工厂类实现这些方法来创建特定的对象。

基本结构：

        （1）抽象工厂（AbstractFactory）：声明了一组用于创建产品对象的操作接口。

        （2）具体工厂（ConcreteFactory）：实现了抽象工厂接口，负责创建具体产品类的对象。

        （3）抽象产品（AbstractProduct）：定义了一组产品的接口。

        （4）具体产品（ConcreteProduct）：实现了抽象产品接口，是具体可使用的产品。

示例：有两个产品族（Car 和 Bike），每个产品族都有两个具体产品（SportsCar、Sedan 和 MountainBike、RoadBike）。

#include <iostream>  
#include <string>  

// 抽象产品  
class Car {  
public:  
    virtual ~Car() {}  
    virtual void show() = 0;  
};  
  
class Bike {  
public:  
    virtual ~Bike() {}  
    virtual void show() = 0;  
};  
  
// 具体产品  
class SportsCar : public Car {  
public:  
    void show() override { std::cout << "SportsCar" << std::endl; }  
};  
  
class Sedan : public Car {  
public:  
    void show() override { std::cout << "Sedan" << std::endl; }  
};  
  
class MountainBike : public Bike {  
public:  
    void show() override { std::cout << "MountainBike" << std::endl; }  
};  
  
class RoadBike : public Bike {  
public:  
    void show() override { std::cout << "RoadBike" << std::endl; }  
};  
  
// 抽象工厂  
class VehicleFactory {  
public:  
    virtual ~VehicleFactory() {}  
    virtual Car* createCar() = 0;      // 纯虚函数，必须被子类重写
    virtual Bike* createBike() = 0;    // 纯虚函数，必须被子类重写
};  
  
// 具体工厂  
class AmericanFactory : public VehicleFactory {  
public:  
    Car* createCar() override { return new SportsCar(); }  
    Bike* createBike() override { return new MountainBike(); }  
};  
  
class EuropeanFactory : public VehicleFactory {  
public:  
    Car* createCar() override { return new Sedan(); }  
    Bike* createBike() override { return new RoadBike(); }  
};  
  
// 客户端代码  
int main() {  
    VehicleFactory* americanFactory = new AmericanFactory();  
    Car* americanCar = americanFactory->createCar();  
    Bike* americanBike = americanFactory->createBike();  
    americanCar->show();  
    americanBike->show();  
  
    VehicleFactory* europeanFactory = new EuropeanFactory();  
    Car* europeanCar = europeanFactory->createCar();  
    Bike* europeanBike = europeanFactory->createBike();  
    europeanCar->show();  
    europeanBike->show();  
  
    // 记得释放内存  
    delete americanCar;  
    delete americanBike;  
    delete europeanCar;  
    delete europeanBike;  
    delete americanFactory;  
    delete europeanFactory;  
  
    return 0;  
}

结果：

SportsCar
MountainBike
Sedan
RoadBike

3、区别

（1）产品类数量：

        简单工厂模式：通常只有一个抽象产品类，可以派生出多个具体产品类。

        抽象工厂模式：有多个抽象产品类，每个抽象产品类都可以派生出多个具体产品类。

（2）工厂类功能：

        简单工厂模式：具体工厂类只能创建一个具体产品类的实例。

        抽象工厂模式：每个具体工厂类可以创建多个具体产品类的实例，即一个工厂可以创建属于同一产品族但不同等级结构的产品。

（3）接口数量：

        简单工厂模式：通常只使用一个接口，用于定义产品的公共方法。

        抽象工厂模式：可以使用无限个接口，每个接口对应一个抽象产品类，定义不同产品族的公共方法。

（4）创建对象方式：

        简单工厂模式：通过传入参数或配置文件来动态决定创建哪个具体产品类的实例。

        抽象工厂模式：无需指定产品的具体类，访问类可以通过抽象工厂接口获取同族的不同等级的产品。

（5）使用场景：

        简单工厂模式：适用于创建同种产品类型的复杂参数对象，尤其是当对象的创建过程很复杂，需要很多参数且大部分参数固定时。

        抽象工厂模式：适用于系统中有多个产品族，每个具体工厂创建同一族但属于不同等级结构的产品的情况。它可以在类的内部对产品族中相关联的多等级产品共同管理。

（6）优缺点：

        简单工厂模式：优点：轻量级，代码结构简单清晰，工厂类可以生产不同的产品。缺点：系统扩展困难，一旦添加新产品就不得不修改工厂逻辑，可能造成工厂逻辑过于复杂，违背了“开放-封闭”原则。

        抽象工厂模式：优点：可以在类的内部对产品族中相关联的多等级产品共同管理，而不必专门引入多个新的类来进行管理。缺点：需要增加额外的抽象类和接口，增加了系统的复杂性。