03-抽象工厂模式-C语言实现

抽象工厂模式：Provide an interface for creating families of related or dependent objects without specifying their concrete classes.（为创建一组相关或相互依赖的对象提供一个接口， 而且无须指定它们的具体类。 ）

抽象工厂模式：

代码实现：

#include <stdio.h>

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

typedef struct {
    void (*operation)();
} AbstractProductB;

// 具体产品A1
typedef struct {
    AbstractProductA abstractProductA;
} ConcreteProductA1;

void ConcreteProductA1_operation() {
    printf("具体产品 A1 的操作\n");
}

// 具体产品A2
typedef struct {
    AbstractProductA abstractProductA;
} ConcreteProductA2;

void ConcreteProductA2_operation() {
    printf("具体产品 A2 的操作\n");
}

// 具体产品B1
typedef struct {
    AbstractProductB abstractProductB;
} ConcreteProductB1;

void ConcreteProductB1_operation() {
    printf("具体产品 B1 的操作\n");
}

// 具体产品B2
typedef struct {
    AbstractProductB abstractProductB;
} ConcreteProductB2;

void ConcreteProductB2_operation() {
    printf("具体产品 B2 的操作\n");
}

// 定义抽象工厂接口
typedef struct {
    AbstractProductA* (*createProductA)();
    AbstractProductB* (*createProductB)();
} AbstractFactory;

// 具体工厂1
typedef struct {
    AbstractFactory abstractFactory;
} ConcreteFactory1;

AbstractProductA* ConcreteFactory1_createProductA() {
    return (AbstractProductA*)malloc(sizeof(ConcreteProductA1));
}

AbstractProductB* ConcreteFactory1_createProductB() {
    return (AbstractProductB*)malloc(sizeof(ConcreteProductB1));
}

// 具体工厂2
typedef struct {
    AbstractFactory abstractFactory;
} ConcreteFactory2;

AbstractProductA* ConcreteFactory2_createProductA() {
    return (AbstractProductA*)malloc(sizeof(ConcreteProductA2));
}

AbstractProductB* ConcreteFactory2_createProductB() {
    return (AbstractProductB*)malloc(sizeof(ConcreteProductB2));
}

int main() {
    AbstractFactory* factory1 = (AbstractFactory*)malloc(sizeof(ConcreteFactory1));
    factory1->createProductA = ConcreteFactory1_createProductA;
    factory1->createProductB = ConcreteFactory1_createProductB;

    AbstractProductA* productA1 = factory1->createProductA();
    AbstractProductB* productB1 = factory1->createProductB();

    productA1->operation();
    productB1->operation();

    free(productA1);
    free(productB1);

    AbstractFactory* factory2 = (AbstractFactory*)malloc(sizeof(ConcreteFactory2));
    factory2->createProductA = ConcreteFactory2_createProductA;
    factory2->createProductB = ConcreteFactory2_createProductB;

    AbstractProductA* productA2 = factory2->createProductA();
    AbstractProductB* productB2 = factory2->createProductB();

    productA2->operation();
    productB2->operation();

    free(productA2);
    free(productB2);

    free(factory1);
    free(factory2);

    return 0;
}

抽象工厂模式（Abstract Factory Pattern）是一种创建型设计模式，它提供了一个接口或抽象类，用于创建相关或依赖对象的家族，而不需要指定具体的类。抽象工厂模式通过封装一组相关的产品对象的创建逻辑，使得客户端可以通过统一的接口来创建这些产品对象。

优点：

1. 将产品家族的创建和使用分离：抽象工厂模式将产品家族的创建逻辑集中在一个工厂类中，使得客户端无需关心具体的产品创建细节。客户端只需要通过抽象工厂接口来创建产品对象，从而将产品的使用与产品的创建解耦。
2. 提供一致性的产品族：抽象工厂模式确保了一组相关的产品对象能够一起使用，保证了产品之间的兼容性和一致性。
3. 便于交换产品系列：由于抽象工厂模式将产品的创建逻辑封装在具体的工厂类中，当需要更换产品系列时，只需切换具体的工厂类即可。

缺点：

1. 不易扩展新的产品：当需要新增产品时，需要修改所有的具体工厂类，违反了开闭原则。这意味着每次新增产品都需要修改抽象工厂和所有具体工厂的代码，可能导致代码变得庞大而复杂。
2. 增加了系统的抽象性和复杂性：引入抽象工厂模式会增加额外的抽象层，使得系统更加复杂，对于简单的产品结构和需求较少的系统可能会显得过度设计。

适用场景：

抽象工厂模式适用于以下情况：

1. 系统需要一组相关的产品对象，并且这些产品对象之间有一定的约束或依赖关系。
2. 客户端希望只使用产品的抽象接口，而无需关心具体的产品实现细节。
3. 需要在运行时动态切换不同的产品系列。

需要注意的是，抽象工厂模式适合处理产品族的创建，而不适合处理单个产品的创建。如果只涉及单个产品的创建，可以考虑使用工厂方法模式。另外，抽象工厂模式在系统中增加了抽象性，如果系统规模较小或者产品结构简单，可能会显得过度设计，此时可以考虑使用简单工厂模式。