Abstract Factory

//C has no interfaces: a struct of pointers to functions plays one

//abstract product A
typedef struct ProductA {
    void (*testA)(const struct ProductA *self);
} ProductA;

//abstract product B
typedef struct ProductB {
    void (*testB)(const struct ProductB *self);
} ProductB;

//concrete product A1
void testA1(const ProductA *) {
    printf("test A1\n");
}

//concrete product A2
void testA2(const ProductA *) {
    printf("test A2\n");
}

//concrete product B1
void testB1(const ProductB *) {
    printf("test B1\n");
}

//concrete product B2
void testB2(const ProductB *) {
    printf("test B2\n");
}

ProductA *productANew(void (*testA)(const ProductA *)) {
    ProductA *product = malloc(sizeof *product);
    product->testA = testA;
    return product;
}

ProductB *productBNew(void (*testB)(const ProductB *)) {
    ProductB *product = malloc(sizeof *product);
    product->testB = testB;
    return product;
}

//abstract factory
typedef struct {
    ProductA *(*createA)(void);
    ProductB *(*createB)(void);
} Factory;

//concrete factory 1
ProductA *createA1(void) {
    return productANew(testA1);
}

ProductB *createB1(void) {
    return productBNew(testB1);
}

//concrete factory 2
ProductA *createA2(void) {
    return productANew(testA2);
}

ProductB *createB2(void) {
    return productBNew(testB2);
}

//client code
void testFactory(const Factory *factory) {
    ProductA *productA = factory->createA();
    ProductB *productB = factory->createB();
    productA->testA(productA);
    productB->testB(productB);
    free(productA);
    free(productB);
}

Factory factory1 = {createA1, createB1};
Factory factory2 = {createA2, createB2};

testFactory(&factory1);
//printed: test A1
//         test B1
testFactory(&factory2);
//printed: test A2
//         test B2