什么是工厂模式？
工厂模式使一种创建对象的设计模式，它提供了一种创建对象的方式，将对象的创建和使用分离。
通过工厂模式，可以根据不同条件创建不同类型的对象，而不需要在客户端代码中显式地指定具体的对象类型。
在c++中如何实现工厂模式？
可以通过定义一个工厂类，该类包含一个或多个创建对象的方法。
这些方法可以根据不同的参数返回不同类型的对象。例如：
假设我们要创建一个图形绘制系统，它可以绘制不同的图形，如圆形和矩形。首先定义一个图形基类Shape：
class Shape {
public:virtual void draw() = 0;
};
然后分别定义Circle和Rectangle类，它们都继承自Shape类：
class Circle : public Shape {
public:void draw() override {std::cout << "Drawing a circle." << std::endl;}
};
class Rectangle : public Shape {
public:void draw() override {std::cout << "Drawing a rectangle." << std::endl;}
};
接着创建一个工厂类ShapeFactory：
class ShapeFactory {
public:static Shape* createShape(const std::string& shapeType) {if (shapeType == "circle") {return new Circle();} else if (shapeType == "rectangle") {return new Rectangle();} else {return nullptr;}}
};
使用方式如下：
int main() {Shape* circle = ShapeFactory::createShape("circle");circle->draw();Shape* rectangle = ShapeFactory::createShape("rectangle");rectangle->draw();delete circle;delete rectangle;return 0;
}
在这个例子中，ShapeFactory的createShape方法根据传入的字符串参数（circle或rectangle）来创建相应的图形对象。这种模式的优点是实现简单，缺点是不符合开闭原则（对扩展开放，对修改封闭），如果要添加新的图形类型，需要修改工厂类的createShape方法。
工厂模式在面向对象编程中的应用场景有哪些？
对象创建过程复杂时：
当对象的创建过程比较复杂，需要多个步骤或者涉及到多个依赖关系时，可以使用工厂模式讲对象的创建封装起来，使客户端代码更加简洁
根据不同条件创建不同类型的对象时：
例如在一个图形绘制系统中，可以根据用户的选择创建不同类型的图形对象
提高代码的可维护性和可扩展性：
当需要添加新的对象类型时，只需要在工厂类添加相应的创建方法，而不需要修改客户端代码
工厂方法模式
概念：工厂方法模式是在简单工厂模式的基础上，将工厂类的创建方法抽象成抽象方法，由具体的工厂子类来实现。这样，当需要添加新的产品类型时，只需要添加新的工厂子类，而不需要修改现有的工厂类。
示例代码：首先，修改工厂类为抽象类：
class ShapeFactory {
public:virtual Shape* createShape() = 0;
};
然后创建具体的工厂子类，如CircleFactory和RectangleFactory：
class CircleFactory : public ShapeFactory {
public:Shape* createShape() override {return new Circle();}
};
class RectangleFactory : public ShapeFactory {
public:Shape* createShape() override {return new Rectangle();}
};
使用方式如下：
int main() {ShapeFactory* circleFactory = new CircleFactory();Shape* circle = circleFactory->createShape();circle->draw();ShapeFactory* rectangleFactory = new RectangleFactory();Shape* rectangle = rectangleFactory->createShape();rectangle->draw();delete circleFactory;delete circle;delete rectangleFactory;delete rectangle;return 0;
}
在这个例子中，CircleFactory和RectangleFactory分别负责创建Circle和Rectangle对象。当需要添加新的图形类型时，只需要创建新的工厂子类并实现createShape方法，符合开闭原则。
抽象工厂模式
概念：抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。它适用于创建产品族的场景，产品族是指位于不同产品等级结构中，功能相关联的产品组成的家族。
示例代码：假设我们的图形绘制系统不仅要绘制图形，还要设置图形的颜色。首先定义颜色接口和图形接口：
class Color {
public:virtual void fill() = 0;
};
class Shape {
public:virtual void draw() = 0;
};
然后定义具体的颜色类和图形类，如Red、Blue、Circle、Rectangle：
class Red : public Color {
public:void fill() override {std::cout << "Filling with red." << std::endl;}
};
class Blue : public Color {
public:void fill() override {std::cout << "Filling with blue." << std::endl;}
};
class Circle : public Shape {
public:void draw() override {std::cout << "Drawing a circle." << std::endl;}
};
class Rectangle : public Shape {
public:void draw() override {std::cout << "Drawing a rectangle." << std::endl;}
};
接着创建抽象工厂类：
class AbstractFactory {
public:virtual Shape* createShape() = 0;virtual Color* createColor() = 0;
};
再创建具体的工厂子类，如ShapeColorFactory1和ShapeColorFactory2：
class ShapeColorFactory1 : public AbstractFactory {
public:Shape* createShape() override {return new Circle();}Color* createColor() override {return new Red();}
};
class ShapeColorFactory2 : public AbstractFactory {
public:Shape* createShape() override {return new Rectangle();}Color* createColor() override {return new Blue();}
};
使用方式如下：
int main() {AbstractFactory* factory1 = new ShapeColorFactory1();Shape* shape1 = factory1->createShape();Color* color1 = factory1->createColor();shape1->draw();color1->fill();AbstractFactory* factory2 = new ShapeColorFactory2();Shape* shape2 = factory2->createShape();Color* color2 = factory2->createColor();shape2->draw();color2->fill();delete factory1;delete shape1;delete color1;delete factory2;delete shape2;delete color2;return 0;
}
在这个例子中，AbstractFactory是抽象工厂类，它定义了创建图形和颜色的抽象方法。ShapeColorFactory1和ShapeColorFactory2是具体的工厂子类，它们分别创建一组相关的产品（如Circle和Red，Rectangle和Blue）。这种模式的优点是代码的可维护性和可扩展性强，缺点是代码结构复杂，实现难度较大。