在C语言编程中，虽然它不是一种面向对象的编程语言，但我们可以通过一些技巧和模式来模拟面向对象的设计。这些模式可以帮助我们提高代码的可读性、可维护性和可扩展性。以下是五种在C语言中常用的面向对象设计模式，它们将帮助你在编程中达到更高的境界。

1. 单例模式（Singleton）

单例模式确保一个类只有一个实例，并提供一个全局访问点。这种模式在需要全局访问某些资源时非常有用。

#include <stdio.h>

typedef struct {
    int value;
} Singleton;

Singleton* getSingleton() {
    static Singleton instance = {0};
    return &instance;
}

int main() {
    Singleton* s1 = getSingleton();
    Singleton* s2 = getSingleton();

    s1->value = 42;
    printf("s1 value: %d\n", s1->value);
    printf("s2 value: %d\n", s2->value);

    return 0;
}

2. 工厂方法模式（Factory Method）

工厂方法模式定义一个接口用于创建对象，但让子类决定实例化哪一个类。这种模式使一个类的实例化延迟到其子类。

#include <stdio.h>
#include <stdlib.h>

typedef struct {
    char* name;
} Product;

typedef struct {
    Product* (*createProduct)(void);
} Factory;

Product* createConcreteProductA() {
    Product* p = (Product*)malloc(sizeof(Product));
    p->name = "Product A";
    return p;
}

Product* createConcreteProductB() {
    Product* p = (Product*)malloc(sizeof(Product));
    p->name = "Product B";
    return p;
}

Factory* getFactory() {
    static Factory factory = {createConcreteProductA};
    return &factory;
}

int main() {
    Factory* factory = getFactory();
    Product* product = factory->createProduct();

    printf("Product: %s\n", product->name);

    free(product);
    return 0;
}

3. 抽象工厂模式（Abstract Factory）

抽象工厂模式提供一个接口，用于创建相关或依赖对象的家族，而不需要指定具体类。

#include <stdio.h>
#include <stdlib.h>

typedef struct {
    void* (*createProductA)(void);
    void* (*createProductB)(void);
} AbstractFactory;

typedef struct {
    void* (*createProductA)(void);
    void* (*createProductB)(void);
} ConcreteFactoryA;

typedef struct {
    void* (*createProductA)(void);
    void* (*createProductB)(void);
} ConcreteFactoryB;

void* createProductAConcreteFactoryA() {
    return malloc(sizeof(int));
}

void* createProductBConcreteFactoryA() {
    return malloc(sizeof(float));
}

void* createProductAConcreteFactoryB() {
    return malloc(sizeof(float));
}

void* createProductBConcreteFactoryB() {
    return malloc(sizeof(int));
}

AbstractFactory* getFactoryA() {
    static ConcreteFactoryA factoryA = {createProductAConcreteFactoryA, createProductBConcreteFactoryA};
    return &factoryA;
}

AbstractFactory* getFactoryB() {
    static ConcreteFactoryB factoryB = {createProductAConcreteFactoryB, createProductBConcreteFactoryB};
    return &factoryB;
}

int main() {
    AbstractFactory* factory = getFactoryA();
    int* productA = (int*)factory->createProductA();
    float* productB = (float*)factory->createProductB();

    printf("Product A: %d\n", *productA);
    printf("Product B: %f\n", *productB);

    free(productA);
    free(productB);

    return 0;
}

4. 适配器模式（Adapter）

适配器模式允许将一个类的接口转换成客户期望的另一个接口。适配器让原本接口不兼容的类可以一起工作。

#include <stdio.h>
#include <stdlib.h>

typedef struct {
    void (*print)(void);
} Adaptee;

typedef struct {
    void (*print)(void);
} Target;

void printAdaptee(Adaptee* adaptee) {
    printf("Adaptee: ");
    adaptee->print();
}

void printTarget(Target* target) {
    printf("Target: ");
    target->print();
}

typedef struct {
    Adaptee* adaptee;
    Target* target;
} Adapter;

void adapterPrint(Adapter* adapter) {
    printTarget(adapter->target);
    adapter->adaptee->print();
}

int main() {
    Adaptee adaptee = {printAdaptee};
    Target target = {adapterPrint};

    Adapter adapter = {&adaptee, &target};

    adapterPrint(&adapter);

    return 0;
}

5. 模板方法模式（Template Method）

模板方法模式定义一个操作中的算法的骨架，将一些步骤延迟到子类中。模板方法让子类在不改变算法结构的情况下重定义算法的某些步骤。

#include <stdio.h>
#include <stdlib.h>

typedef struct {
    void (*execute)(void);
} TemplateMethod;

typedef struct {
    void (*operation1)(void);
    void (*operation2)(void);
} ConcreteTemplateMethod;

void operation1(ConcreteTemplateMethod* ctm) {
    printf("Operation 1\n");
}

void operation2(ConcreteTemplateMethod* ctm) {
    printf("Operation 2\n");
}

void execute(ConcreteTemplateMethod* ctm) {
    ctm->operation1();
    ctm->operation2();
}

int main() {
    ConcreteTemplateMethod ctm = {operation1, operation2};

    TemplateMethod tm = {execute};

    tm.execute(&ctm);

    return 0;
}

通过应用这些面向对象设计模式，即使是在C语言这样的非面向对象编程语言中，你也可以写出更优雅、更高效的代码。