写一段c++工厂模式代码

### 回答1：

// 工厂模式代码
public interface Shape {
void draw();
}

public class Rectangle implements Shape {
@Override
public void draw() {
System.out.println("画一个矩形");
}
}

public class Square implements Shape {
@Override
public void draw() {
System.out.println("画一个正方形");
}
}

public class ShapeFactory {
public static Shape getShape(String shapeType){
if(shapeType == null){
return null;
}
if(shapeType.equalsIgnoreCase("RECTANGLE")){
return new Rectangle();
} else if(shapeType.equalsIgnoreCase("SQUARE")){
return new Square();
}
return null;
}
}

### 回答2：
工厂模式是一种常用的设计模式，它通过定义一个创建对象的接口，但由子类决定实例化的类是哪一个。这样，工厂模式让类的实例化延迟到其子类。

下面是一个示例的C++代码，展示了如何使用工厂模式创建不同类型的产品对象：

#include <iostream>
using namespace std;

// 抽象产品类
class Product {
public:
    virtual void operation() = 0;
};

// 具体产品类A
class ConcreteProductA : public Product {
public:
    void operation() {
        cout << "Concrete Product A" << endl;
    }
};

// 具体产品类B
class ConcreteProductB : public Product {
public:
    void operation() {
        cout << "Concrete Product B" << endl;
    }
};

// 工厂类
class Factory {
public:
    virtual Product* createProduct() = 0;
};

// 具体工厂类A
class ConcreteFactoryA : public Factory {
public:
    Product* createProduct() {
        return new ConcreteProductA();
    }
};

// 具体工厂类B
class ConcreteFactoryB : public Factory {
public:
    Product* createProduct() {
        return new ConcreteProductB();
    }
};


int main() {
    // 创建工厂对象
    Factory* factoryA = new ConcreteFactoryA();
    Factory* factoryB = new ConcreteFactoryB();

    // 通过工厂对象创建具体产品对象
    Product* productA = factoryA->createProduct();
    productA->operation();

    Product* productB = factoryB->createProduct();
    productB->operation();

    delete factoryA;
    delete factoryB;
    delete productA;
    delete productB;

    return 0;
}

在以上代码中，抽象产品类`Product`定义了一个操作函数`operation`，具体产品类`ConcreteProductA`和`ConcreteProductB`继承自抽象产品类，并实现了操作函数。工厂类`Factory`定义了一个创建产品对象的虚函数`createProduct`，具体工厂类`ConcreteFactoryA`和`ConcreteFactoryB`继承自工厂类，并实现了创建产品对象的函数。在`main`函数中，我们创建了工厂对象并通过工厂对象创建了具体产品对象，并调用了产品对象的操作函数。最后，我们释放了动态分配的内存。

### 回答3：
C工厂模式是一种常用的设计模式，用于创建和管理不同类型的对象。它通过提供一个共同的接口来创建对象，而不必暴露底层实现的细节。下面是一个使用C语言实现的简单工厂模式代码：

#include <stdio.h>

// 定义一个基本的产品接口
typedef struct {
    void (*showInfo)();
} Product;

// 定义具体的产品A
typedef struct {
    Product product;
    int dataA;
} ConcreteProductA;

// 定义具体的产品B
typedef struct {
    Product product;
    char dataB[20];
} ConcreteProductB;

// 实现具体产品A的方法
void ConcreteProductA_showInfo() {
    printf("This is Product A\n");
}

// 实现具体产品B的方法
void ConcreteProductB_showInfo() {
    printf("This is Product B\n");
}

// 工厂方法，根据不同的参数创建不同的产品
Product* createProduct(int type) {
    Product *product = NULL;
    switch (type) {
        case 1:
            product = (Product *)malloc(sizeof(ConcreteProductA));
            product->showInfo = ConcreteProductA_showInfo;
            ((ConcreteProductA *)product)->dataA = 100;
            break;
        case 2:
            product = (Product *)malloc(sizeof(ConcreteProductB));
            product->showInfo = ConcreteProductB_showInfo;
            strcpy(((ConcreteProductB *)product)->dataB, "Hello Factory");
            break;
        default:
            printf("Invalid type\n");
            break;
    }
    return product;
}

int main() {
    // 使用工厂方法创建产品A
    Product *productA = createProduct(1);
    productA->showInfo();

    // 使用工厂方法创建产品B
    Product *productB = createProduct(2);
    productB->showInfo();

    // 释放内存
    free(productA);
    free(productB);
    
    return 0;
}

以上代码中，首先定义了一个基本的产品接口`Product`，然后分别定义了具体的产品A和产品B。每个具体产品都实现了`Product`接口的方法。接着实现了工厂方法`createProduct`，根据传入的参数类型，动态创建对应的产品对象，并返回其指针。

在主函数中，我们分别使用工厂方法创建了一个产品A和一个产品B，并调用了它们的showInfo方法来展示产品信息。最后释放了所分配的内存空间。

这段代码演示了如何使用C语言实现简单的工厂模式，通过封装底层的对象创建过程，隐藏了具体产品的细节，提供了一个统一的接口来创建和管理不同类型的产品对象。