C语言开发中的“设计模式”

在 C 语言开发中，虽然没有像面向对象编程语言那样的设计模式，但是可以借鉴一些通用的设计原则和思想。以下是几种常见的设计模式：

1、单例模式

单例模式确保一个类只有一个实例，并提供了全局访问点。在C语言中，可以使用静态变量来实现单例模式。具体来说，可以在一个函数中定义一个静态变量，每次调用这个函数时都返回这个静态变量的地址，从而保证只有一个实例。

#include <stdio.h>

typedef struct {
    int count;
} Singleton;

static Singleton instance = {0};

Singleton* get_instance() {
    return &instance;
}

int main() {
    Singleton* s1 = get_instance();
    Singleton* s2 = get_instance();
    printf("%d\n", s1 == s2);  // 输出 1，表示两个指针指向同一个实例
    return 0;
}

上述代码中，通过get_instance()函数返回instance静态变量的地址，从而实现了单例模式。因为instance是静态变量，所以在程序运行期间只会分配一次内存，从而保证了只有一个实例。 

2、工厂模式

工厂模式是一种创建型设计模式，它提供了一种创建对象的最佳方式。在C语言中，可以通过函数指针来实现工厂模式。具体来说，可以定义一个函数指针类型，然后在程序中根据需要设置这个函数指针，从而动态创建不同的对象。

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

typedef struct {
    int x;
    int y;
} Point;

typedef Point (*Factory)(int, int);

Point create_point(int x, int y) {
    Point p = {x, y};
    return p;
}

int main() {
    Factory factory = create_point;
    Point p = factory(1, 2);
    printf("(%d, %d)\n", p.x, p.y);  // 输出 (1, 2)
    return 0;
}

上述代码中，定义了一个函数指针类型Factory，并定义了一个create_point()函数，用于创建Point对象。然后，在程序中定义一个factory变量，将其赋值为create_point()函数的地址，从而动态创建Point对象。通过这种方式，可以实现动态创建不同类型的对象，从而增加程序的灵活性和可维护性。 

3、策略模式

策略模式是一种行为型设计模式，它定义了算法族，分别封装起来，让它们之间可以相互替换。在C语言中，可以使用函数指针来实现策略模式。具体来说，可以定义一个函数指针类型，然后将不同的算法封装为不同的函数，最后在程序中根据需要设置这个函数指针，从而实现算法的替换。

#include <stdio.h>

typedef int (*Comparator)(int, int);

int compare_int(int a, int b) {
    return a - b;
}

int compare_double(double a, double b) {
    return (int)(a - b);
}

void sort(void* array, int length, size_t element_size, Comparator comparator) {
    char* start = (char*)array;
    for (int i = 0; i < length; ++i) {
        for (int j = i + 1; j < length; ++j) {
            char* left = start + i * element_size;
            char* right = start + j * element_size;
            if (comparator(left, right) > 0) {
                char buffer[element_size];
                memcpy(buffer, left, element_size);
                memcpy(left, right, element_size);
                memcpy(right, buffer, element_size);
            }
        }
    }
}

int main() {
    int arr[] = {3, 2, 1};
    sort(arr, 3, sizeof(int), compare_int);
    for (int i = 0; i < 3; ++i) {
        printf("%d ", arr[i]);  // 输出 1 2 3
    }
    printf("\n");
    double arr2[] = {3.3, 2.2, 1.1};
    sort(arr2, 3, sizeof(double), compare_double);
    for (int i = 0; i < 3; ++i) {
        printf("%.1f ", arr2[i]);  // 输出 1.1 2.2 3.3
    }
    printf("\n");
    return 0;
}

以上是几种常见的设计模式在 C 语言中的实现。需要注意的是，C 语言并不是面向对象编程语言，因此在使用这些设计模式时需要注意它们的适用范围和限制。