简单工厂模式示例
定义产品抽象类
首先，定义一个抽象产品类Product，它是所有具体产品类的基类，包含一个纯虚函数operation，用于定义产品的操作行为。
class Product {public:virtual void operation() = 0;virtual ~Product() {}};
定义具体产品类
接着，创建两个具体产品类ConcreteProductA和ConcreteProductB，它们继承自Product类，并实现了operation函数。
class ConcreteProductA : public Product {public:void operation() override {std::cout << "ConcreteProductA operation" << std::endl;}};class ConcreteProductB : public Product {public:void operation() override {std::cout << "ConcreteProductB operation" << std::endl;}};
定义工厂类
然后，定义一个简单工厂类SimpleFactory，它有一个createProduct函数，根据传入的参数来创建不同类型的产品。
class SimpleFactory {public:Product* createProduct(const std::string& type) {if (type == "A") {return new ConcreteProductA();} else if (type == "B") {return new ConcreteProductB();}return nullptr;}};
使用工厂类创建产品
最后，在main函数中使用简单工厂来创建产品并调用产品的操作函数。
int main() {SimpleFactory factory;Product* productA = factory.createProduct("A");if (productA) {productA->operation();delete productA;}Product* productB = factory.createProduct("B");if (productB) {productB->operation();delete productB;}return 0;}
解释
简单工厂模式将对象的创建和使用分离。在这个例子中，SimpleFactory类负责创建Product的具体子类对象。当需要创建不同类型的产品时，只需要调用工厂类的createProduct函数并传入相应的类型参数，就可以得到所需的产品对象。这样可以避免在客户端代码中直接使用new操作符来创建对象，提高了代码的可维护性和可扩展性。如果要添加新的产品类型，只需要在工厂类的createProduct函数中添加相应的创建逻辑即可。
工厂方法模式示例
定义产品抽象类和具体产品类（与简单工厂模式类似）
产品抽象类Product和具体产品类ConcreteProductA、ConcreteProductB的定义与简单工厂模式相同。
定义抽象工厂类
创建一个抽象工厂类Factory，它包含一个纯虚函数createProduct，用于创建产品对象。
class Factory {public:virtual Product* createProduct() = 0;virtual ~Factory() {}};
定义具体工厂类
为每个具体产品类创建对应的具体工厂类。例如，ConcreteFactoryA用于创建ConcreteProductA，ConcreteFactoryB用于创建ConcreteProductB。
class ConcreteFactoryA : public Factory {public:Product* createProduct() override {return new ConcreteProductA();}};class ConcreteFactoryB : public Factory {public:Product* createProduct() override {return new ConcreteProductB();}};
使用工厂类创建产品
在main函数中，通过具体工厂类来创建产品并调用产品的操作函数。
int main() {ConcreteFactoryA factoryA;Product* productA = factoryA.createProduct();if (productA) {productA->operation();delete productA;}ConcreteFactoryB factoryB;Product* productB = factoryB.createProduct();if (productB) {productB->operation();delete productB;}return 0;}
解释
工厂方法模式在简单工厂模式的基础上，将工厂类也进行了抽象。每个具体产品类都有对应的具体工厂类。这种模式符合开闭原则，即当需要添加新的产品类型时，只需要创建新的具体产品类和对应的具体工厂类，而不需要修改现有的代码。这样可以更好地应对产品类型的变化，使得代码的扩展性更强。
抽象工厂模式示例
定义产品族抽象类和具体产品类
假设我们有两个产品族，一个是Shape产品族，包含Circle和Rectangle；另一个是Color产品族，包含Red和Blue。
首先定义Shape产品族的抽象类和具体类：
class Shape {public:virtual void draw() = 0;virtual ~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;}};
然后定义Color产品族的抽象类和具体类：
class Color {public:virtual void fill() = 0;virtual ~Color() {}};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;}};
定义抽象工厂类
创建一个抽象工厂类AbstractFactory，它包含两个纯虚函数createShape和createColor，用于分别创建Shape和Color产品。
class AbstractFactory {public:virtual Shape* createShape() = 0;virtual Color* createColor() = 0;virtual ~AbstractFactory() {}};
定义具体工厂类
为每个产品组合创建具体工厂类。例如，ShapeColorFactory1用于创建Circle和Red，ShapeColorFactory2用于创建Rectangle和Blue。
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();}};
使用抽象工厂类创建产品组合
在main函数中，通过具体工厂类来创建产品组合并调用产品的操作函数。
int main() {ShapeColorFactory1 factory1;Shape* shape1 = factory1.createShape();Color* color1 = factory1.createColor();if (shape1 && color1) {shape1->draw();color1->fill();delete shape1;delete color1;}ShapeColorFactory2 factory2;Shape* shape2 = factory2.createShape();Color* color2 = factory2.createColor();if (shape2 && color2) {shape2->draw();color2->fill();delete shape2;delete color2;}return 0;}
解释
抽象工厂模式提供了一种创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。在这个例子中，AbstractFactory类定义了创建Shape和Color产品的抽象方法。具体工厂类实现了这些方法，用于创建特定组合的产品。这种模式适用于创建产品族，当需要创建不同的产品族组合时，只需要使用相应的具体工厂类即可。它使得代码更加灵活，能够更好地应对产品族的变化，并且保证了产品族内产品的一致性。
