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

结果：