[c设计模式]抽象工厂模式 (from chatgpt)

抽象工厂模式是一种创建型设计模式，它允许客户端通过接口而不是具体类来创建相关对象的系列。在C语言中，我们可以使用函数指针和结构体来实现抽象工厂模式。

以下是一个抽象工厂模式的C语言示例：

#include 
#include 

// 抽象产品A
typedef struct ProductA {
    char name[20];
    int price;
} ProductA;

// 抽象产品B
typedef struct ProductB {
    char name[20];
    int quantity;
} ProductB;

// 抽象工厂接口
typedef struct AbstractFactory {
    ProductA *(*createProductA)(void);
    ProductB *(*createProductB)(void);
} AbstractFactory;

// 具体产品A1
typedef struct ConcreteProductA1 {
    ProductA productA;
} ConcreteProductA1;

// 创建具体产品A1的工厂函数
ProductA *createConcreteProductA1(void) {
    ConcreteProductA1 *pA1 = (ConcreteProductA1 *)malloc(sizeof(ConcreteProductA1));
    pA1->productA.price = 100;
    sprintf(pA1->productA.name, "Product A1");
    return (ProductA *)pA1;
}

// 具体产品B1
typedef struct ConcreteProductB1 {
    ProductB productB;
} ConcreteProductB1;

// 创建具体产品B1的工厂函数
ProductB *createConcreteProductB1(void) {
    ConcreteProductB1 *pB1 = (ConcreteProductB1 *)malloc(sizeof(ConcreteProductB1));
    pB1->productB.quantity = 200;
    sprintf(pB1->productB.name, "Product B1");
    return (ProductB *)pB1;
}

// 工厂1生产A和B
typedef struct Factory1 {
    AbstractFactory factory;
} Factory1;

// 工厂1创建产品A的函数
ProductA *createProductA_Factory1(void) {
    return createConcreteProductA1();
}

// 工厂1创建产品B的函数
ProductB *createProductB_Factory1(void) {
    return createConcreteProductB1();
}

// 工厂2的具体产品A2
typedef struct ConcreteProductA2 {
    ProductA productA;
} ConcreteProductA2;

// 创建具体产品A2的工厂函数
ProductA *createConcreteProductA2(void) {
    ConcreteProductA2 *pA2 = (ConcreteProductA2 *)malloc(sizeof(ConcreteProductA2));
    pA2->productA.price = 200;
    sprintf(pA2->productA.name, "Product A2");
    return (ProductA *)pA2;
}

// 工厂2的具体产品B2
typedef struct ConcreteProductB2 {
    ProductB productB;
} ConcreteProductB2;

// 创建具体产品B2的工厂函数
ProductB *createConcreteProductB2(void) {
    ConcreteProductB2 *pB2 = (ConcreteProductB2 *)malloc(sizeof(ConcreteProductB2));
    pB2->productB.quantity = 300;
    sprintf(pB2->productB.name, "Product B2");
    return (ProductB *)pB2;
}

// 工厂2生产A和B
typedef struct Factory2 {
    AbstractFactory factory;
} Factory2;

// 工厂2创建产品A的函数
ProductA *createProductA_Factory2(void) {
    return createConcreteProductA2();
}

// 工厂2创建产品B的函数
ProductB *createProductB_Factory2(void) {
    return createConcreteProductB2();
}

// 客户端
int main(void) {
    AbstractFactory *factories[2];
    factories[0] = &(Factory1){ .factory = { createProductA_Factory1, createProductB_Factory1 } };
    factories[1] = &(Factory2){ .factory = { createProductA_Factory2, createProductB_Factory2 } };

    for (int i = 0; i < 2; i++) {
        AbstractFactory *factory = factories[i];
        printf("Factory%d:
", i + 1);
        printf("ProductA: %s ($%d)
", factory->createProductA()->name, factory->createProductA()->price);
        printf("ProductB: %s (%d)
", factory->createProductB()->name, factory->createProductB()->quantity);
    }

    return 0;
}

在这个示例中，我们创建了两种不同的具体工厂（Factory1和Factory2），每种工厂都能生产两种不同的抽象产品（ProductA和ProductB）。这个示例中使用了C语言的结构体和函数指针实现了抽象工厂模式的核心机制，通过使用函数指针，我们可以轻松地切换具体产品的实现。