C语言的模板与泛型编程你了解吗

C语言的模板与泛型编程攻略

概述

模板与泛型编程是现代高级编程语言的一个重要特性，旨在提高代码的复用和灵活性。但在C语言中并不直接支持模板和泛型编程，因此需要通过一些技巧和工具去实现相应的功能。本文将针对C语言的模板与泛型编程做详细的讲解。

C语言中的模板

宏定义

宏定义是C语言中实现模板的一种方式，可以通过宏定义来实现泛型编程的功能。

下面是一个示例，定义了一个求两个数中的最大值的宏：

#define MAX(a, b) ((a) > (b) ? (a) : (b))

可以看到，MAX这个宏可以接受任意类型的参数，并返回一个最大值。使用时，可以像下面这样调用：

int max_int = MAX(3, 5);
float max_float = MAX(1.2f, 3.4f);

泛型指针

另一种实现模板的方式是使用泛型指针，即void指针。通过将不同类型的数据都强制转换为void指针，可以实现类似于C++中的泛型编程的功能。

下面是一个示例，定义了一个交换两个数的函数：

void swap(void *a, void *b, size_t size) {
    void *tmp = malloc(size);
    memcpy(tmp, a, size);
    memcpy(a, b, size);
    memcpy(b, tmp, size);
    free(tmp);
}

可以看到，这个函数可以接受任意类型的参数，并在内部使用了memcpy函数进行数据拷贝，实现了交换两个数的功能。

使用时，可以像下面这样调用：

int a = 3, b = 5;
swap(&a, &b, sizeof(int));

float c = 1.2f, d = 3.4f;
swap(&c, &d, sizeof(float));

C语言中的泛型编程

void指针

在C语言中，void指针可以扮演泛型指针的角色，可以将不同类型的数据都强制转换为void指针，实现泛型编程的功能。

下面是一个示例，定义了一个求两个数中的最大值的函数：

void *max(void *a, void *b, size_t size, int (*cmp)(const void *, const void *)) {
    return cmp(a, b) > 0 ? a : b;
}

可以看到，这个函数可以接受任意类型的参数，并使用了void指针和函数指针来实现泛型编程的功能，同时也可以接受用户自定义的比较函数。

使用时，可以像下面这样调用：

int a = 3, b = 5;
int max_int = *(int *)max(&a, &b, sizeof(int), cmp_int);

float c = 1.2f, d = 3.4f;
float max_float = *(float *)max(&c, &d, sizeof(float), cmp_float);

其中cmp_int和cmp_float分别是用于比较两个数大小的函数。

泛型结构体

除了使用void指针外，可以通过定义泛型结构体来实现更加灵活的泛型编程。

下面是一个示例，定义了一个泛型的栈结构体：

typedef struct {
    void *data;
    size_t size;
    size_t capacity;
} stack_t;

stack_t *create_stack(size_t elem_size, size_t capacity) {
    stack_t *s = malloc(sizeof(stack_t));
    s->data = malloc(elem_size * capacity);
    s->size = elem_size;
    s->capacity = capacity;
    return s;
}

void push(stack_t *s, void *elem) {
    assert(s->size > 0);
    if (s->capacity == 0) {
        s->data = malloc(s->size);
        s->capacity = 1;
    } else if (s->capacity * s->size <= s->size) {
        s->data = realloc(s->data, s->size * s->capacity * 2);
        s->capacity *= 2;
    }
    memcpy(s->data + s->size * (s->capacity - 1), elem, s->size);
}

void pop(stack_t *s, void *elem) {
    assert(elem != NULL && s->capacity > 0);
    memcpy(elem, s->data + s->size * (s->capacity - 1), s->size);
    s->capacity--;
    if (s->capacity == 0) {
        free(s->data);
        s->data = NULL;
    } else if (s->capacity * s->size <= s->size / 4) {
        s->data = realloc(s->data, s->size * s->capacity / 2);
        s->capacity /= 2;
    }
}

可以看到，这个栈结构体通过使用void指针实现了任意类型的数据存储，同时还支持动态扩容和缩容的功能。

使用时，可以像下面这样调用：

stack_t *int_stack = create_stack(sizeof(int), 10);
int a = 3;
push(int_stack, &a);
int b;
pop(int_stack, &b);

stack_t *float_stack = create_array(sizeof(float), 10);
float c = 1.2f;
push(float_stack, &c);
float d;
pop(float_stack, &d);

其中int_stack和float_stack分别是存储int和float类型数据的栈结构体。

结论

通过宏定义、void指针和泛型结构体的使用，可以在C语言中实现模板和泛型编程的功能，提高代码的复用性和灵活性。还可以结合函数指针和动态内存分配等技术，实现更加强大的泛型算法和数据结构。