使用ANSI C的工厂模式实现

// 抽象产品接口
typedef struct {
    void (*operation)(void);
} Product;

// 具体产品类A
typedef struct {
    Product product;
} ConcreteProductA;

void ConcreteProductA_operation(void) {
    printf("ConcreteProductA operation\n");
}

// 具体产品类B
typedef struct {
    Product product;
} ConcreteProductB;

void ConcreteProductB_operation(void) {
    printf("ConcreteProductB operation\n");
}

// 工厂接口
typedef struct {
    Product* (*createProduct)(void);
} Factory;

// 具体工厂类A
typedef struct {
    Factory factory;
} ConcreteFactoryA;

Product* ConcreteFactoryA_createProduct(void) {
    ConcreteProductA* product = malloc(sizeof(ConcreteProductA));
    product->product.operation = ConcreteProductA_operation;
    return (Product*)product;
}

// 具体工厂类B
typedef struct {
    Factory factory;
} ConcreteFactoryB;

Product* ConcreteFactoryB_createProduct(void) {
    ConcreteProductB* product = malloc(sizeof(ConcreteProductB));
    product->product.operation = ConcreteProductB_operation;
    return (Product*)product;
}

int main() {
    // 使用具体工厂类A创建产品
    Factory* factoryA = (Factory*)malloc(sizeof(ConcreteFactoryA));
    factoryA->createProduct = ConcreteFactoryA_createProduct;
    Product* productA = factoryA->createProduct();
    productA->operation();

    // 使用具体工厂类B创建产品
    Factory* factoryB = (Factory*)malloc(sizeof(ConcreteFactoryB));
    factoryB->createProduct = ConcreteFactoryB_createProduct;
    Product* productB = factoryB->createProduct();
    productB->operation();

    free(productA);
    free(productB);
    free(factoryA);
    free(factoryB);

    return 0;
}