用c语言实现抽象工厂模式

抽象工厂模式是一种创建型设计模式，它允许客户端代码使用抽象接口来创建一组相关或依赖对象，而无需指定其具体类。

在C语言中，可以使用函数指针来模拟抽象类和虚函数，从而实现抽象工厂模式。

下面是一个简单的示例，演示如何使用C语言实现抽象工厂模式：

#include <stdio.h>

// 定义抽象产品1接口
typedef struct {
    void (*operation1)(void);
} AbstractProduct1;

// 定义抽象产品2接口
typedef struct {
    void (*operation2)(void);
} AbstractProduct2;

// 定义抽象工厂接口
typedef struct {
    AbstractProduct1* (*createProduct1)(void);
    AbstractProduct2* (*createProduct2)(void);
} AbstractFactory;

// 定义具体产品1A
typedef struct {
    AbstractProduct1 base;
} Product1A;

// 实现具体产品1A的操作1
static void operation1A(void)
{
    printf("Product 1A Operation 1\n");
}

// 定义具体产品2A
typedef struct {
    AbstractProduct2 base;
} Product2A;

// 实现具体产品2A的操作2
static void operation2A(void)
{
    printf("Product 2A Operation 2\n");
}

// 定义具体工厂A
typedef struct {
    AbstractFactory base;
} FactoryA;

// 实现具体工厂A的createProduct1函数
static AbstractProduct1* createProduct1A(void)
{
    Product1A* product = malloc(sizeof(Product1A));
    product->base.operation1 = operation1A;
    return &product->base;
}

// 实现具体工厂A的createProduct2函数
static AbstractProduct2* createProduct2A(void)
{
    Product2A* product = malloc(sizeof(Product2A));
    product->base.operation2 = operation2A;
    return &product->base;
}

// 定义具体产品1B
typedef struct {
    AbstractProduct1 base;
} Product1B;

// 实现具体产品1B的操作1
static void operation1B(void)
{
    printf("Product 1B Operation 1\n");
}

// 定义具体产品2B
typedef struct {
    AbstractProduct2 base;
} Product2B;

// 实现具体产品2B的操作2
static void operation2B(void)
{
    printf("Product 2B Operation 2\n");
}

// 定义具体工厂B
typedef struct {
    AbstractFactory base;
} FactoryB;

// 实现具体工厂B的createProduct1函数
static AbstractProduct1* createProduct1B(void)
{
    Product1B* product = malloc(sizeof(Product1B));
    product->base.operation1 = operation1B;
    return &product->base;
}

// 实现具体工厂B的createProduct2函数
static AbstractProduct2* createProduct2B(void)
{
    Product2B* product = malloc(sizeof(Product2B));
    product->base.operation2 = operation2B;
    return &product->base;
}

int main()
{
    // 创建具体工厂A
    FactoryA factoryA;
    factoryA.base.createProduct1 = createProduct1A;
    factoryA.base.createProduct2 = createProduct2A;

    // 使用具体工厂A创建产品
    AbstractProduct1* product1A = factoryA.base.createProduct1();
    AbstractProduct2* product2A = factoryA.base.createProduct2();

    // 调用产品的操作
    product1A->operation1();
    product2A->operation2();

    // 创建具体工厂B
    FactoryB factoryB;
    factoryB.base.createProduct1 = createProduct1B;
    factoryB.base.createProduct2 = createProduct2B;

    // 使用具体工厂B创建产品
    AbstractProduct1* product1B = factoryB.base.createProduct1();
    AbstractProduct2* product2B = factoryB.base.createProduct2();

    // 调用产品的操作
    product1B->operation1();
    product2B->operation2();

    return 0;
}

在上面的示例中，我们定义了抽象产品1和抽象产品2的接口，以及抽象工厂的接口。然后使用具体的产品和工厂来实现这些接口。最后，我们可以使用具体工厂来创建具体产品，并调用它们的操作。

需要注意的是，在C语言中，需要手动管理内存，因此需要在使用完产品后释放它们的内存。