C++面向对象的工厂方法模式demo

### 回答1：
下面是一个使用 C 语言实现面向对象的工厂方法模式的简单示例：

#include <stdio.h>
#include <stdlib.h>

typedef struct Product Product;
struct Product {
  void (*use)(Product*);
};

typedef struct ConcreteProductA ConcreteProductA;
struct ConcreteProductA {
  Product product;
  int concrete_a_data;
};

void concrete_product_a_use(Product* product) {
  ConcreteProductA* concrete_product_a = (ConcreteProductA*) product;
  printf("ConcreteProductA use, concrete_a_data = %d\n", concrete_product_a->concrete_a_data);
}

typedef struct ConcreteProductB ConcreteProductB;
struct ConcreteProductB {
  Product product;
  int concrete_b_data;
};

void concrete_product_b_use(Product* product) {
  ConcreteProductB* concrete_product_b = (ConcreteProductB*) product;
  printf("ConcreteProductB use, concrete_b_data = %d\n", concrete_product_b->concrete_b_data);
}

typedef struct Creator Creator;
struct Creator {
  Product* (*factory_method)();
};

typedef struct ConcreteCreatorA ConcreteCreatorA;
struct ConcreteCreatorA {
  Creator creator;
};

Product* concrete_creator_a_factory_method() {
  ConcreteProductA* concrete_product_a = (ConcreteProductA*) malloc(sizeof(ConcreteProductA));
  concrete_product_a->product.use = concrete_product_a_use;
  concrete_product_a->concrete_a_data = rand() % 100;
  return (Product*) concrete_product_a;
}

typedef struct ConcreteCreatorB ConcreteCreatorB;
struct ConcreteCreatorB {
  Creator creator;
};

Product* concrete_creator_b_factory_method() {
  ConcreteProductB* concrete_product_b = (ConcreteProductB*) malloc(sizeof(ConcreteProductB));
  concrete_product_b->product.use = concrete_product_b_use;
  concrete_product_b->concrete_b_data = rand() % 100;
  return (Product*) concrete_product_b;
}

int main() {
  Creator* creator = (Creator*) malloc(sizeof(ConcreteCreatorA));
  creator->factory_method = concrete_creator_a_factory_method;
  Product* product = creator->factory_method();
  product->use(product);
  free(product);

  creator = (Creator*) malloc(sizeof(ConcreteCreatorB));
  creator->factory_method = concrete_creator_b_factory_method;
  product = creator->factory_method();
  product->use(product);
  free(product);

  free(creator);

  

### 回答2：
面向对象的工厂方法模式是一种创建型设计模式，它将对象的创建委托给工厂类，实现了对象的创建与使用的分离，可以灵活地添加新的产品类型而无需修改客户端代码。
以一个简单的图形绘制工具为例，我们可以使用工厂方法模式实现对不同图形对象的创建。

首先，我们定义一个抽象的图形类，包含绘制方法draw()：
class Shape {
    public abstract void draw();
}

然后，定义不同的具体图形类，继承自抽象图形类：
class Rectangle extends Shape {
    public void draw() {
        // 绘制矩形的具体实现
    }
}

class Circle extends Shape {
    public void draw() {
        // 绘制圆形的具体实现
    }
}

接下来，我们定义一个抽象的图形工厂类，包含创建图形对象的方法createShape()：
class ShapeFactory {
    public abstract Shape createShape();
}

然后，定义不同的具体图形工厂类，继承自抽象图形工厂类：
class RectangleFactory extends ShapeFactory {
    public Shape createShape() {
        return new Rectangle();
    }
}

class CircleFactory extends ShapeFactory {
    public Shape createShape() {
        return new Circle();
    }
}

最后，我们可以在客户端代码中通过具体的工厂类创建具体的图形对象并调用相应的方法：
ShapeFactory factory = new RectangleFactory();
Shape shape = factory.createShape();
shape.draw();

这样，通过工厂方法模式，我们可以实现对不同图形对象的创建和使用的解耦，从而提高了系统的扩展性和灵活性。  

### 回答3：
工厂方法模式是一种创建型设计模式，用于解耦具体对象的创建和使用。在面向对象的编程中，通常需要通过实例化具体的对象来完成某个功能，这会导致代码耦合度高、可维护性差。而工厂方法模式通过定义一个抽象工厂类，让子类具体实现创建对象的方法，以达到解耦的效果。

下面以一个计算器为例来演示工厂方法模式的使用。

首先，我们定义一个抽象的计算器接口Calculator，其中包含了两个方法：add和subtract。

接着，我们创建两个具体类CalculatorAdd和CalculatorSubtract，它们分别实现了Calculator接口，并分别实现了add和subtract方法，用于进行加法和减法运算。

然后，我们创建一个抽象工厂类CalculatorFactory，其中包含一个创建计算器的抽象方法createCalculator。

最后，我们创建两个具体工厂类CalculatorAddFactory和CalculatorSubtractFactory，它们分别实现了CalculatorFactory接口，并实现了createCalculator方法，分别用来创建加法计算器和减法计算器的对象。

这样，当我们需要使用计算器时，只需通过具体工厂类创建对应的计算器对象，并直接使用其方法进行计算，无需关心具体对象的创建细节。

工厂方法模式可以将对象的创建和使用分离开来，提高代码的可维护性和可扩展性。当需要新增一种计算器时，只需创建一个新的具体工厂类和计算器类，并通过扩展抽象工厂类和接口来完成，无需修改已有的代码。同时，也方便进行单元测试和代码的复用。

总之，工厂方法模式是一种常用的设计模式，在面向对象的编程中具有重要的应用价值。