C语言void指针作参数，产生泛型函数效果

使用void指针作为参数可以实现类似泛型函数的效果，因为void指针可以指向任意类型的数据。以下是一个简单的例子：

#include <stdio.h>

void print(void *data, int type) {
    switch (type) {
        case 0:
            printf("%d\n", *(int *)data);
            break;
        case 1:
            printf("%f\n", *(float *)data);
            break;
        case 2:
            printf("%c\n", *(char *)data);
            break;
    }
}

int main() {
    int x = 10;
    float y = 3.14;
    char z = 'a';

    print(&x, 0);
    print(&y, 1);
    print(&z, 2);

    return 0;
}

在这个例子中，print函数的第一个参数是void指针，可以接受任何类型的数据。第二个参数type表示数据的类型，0表示整型，1表示浮点型，2表示字符型。在函数内部，根据type的值，通过类型转换将void指针转换成相应类型的指针，然后再通过指针取出数据进行打印。

这样就可以使用一个函数打印不同类型的数据了，实现了类似泛型函数的效果。

相关问题

C语言怎么利用void*让函数实现类似泛型的机制

在C语言中，void指针可以指向任何类型的数据，因此可以利用void*实现类似泛型的机制。具体实现方法如下：

1. 定义一个结构体，包含一个void*类型的成员和一个枚举类型的成员，用于标识void*指向的数据类型。

2. 定义一个函数，使用void*作为参数，实现对任意类型数据的操作。

3. 在调用函数时，将需要操作的数据转换成void*类型，并在函数内部根据枚举类型的值进行相应的操作。

下面是一个简单的示例代码：

typedef enum {
    INT,
    DOUBLE,
    STRING
} DataType;

typedef struct {
    void* data;
    DataType type;
} Any;

void printData(Any any) {
    switch (any.type) {
        case INT:
            printf("%d\n", *(int*)(any.data));
            break;
        case DOUBLE:
            printf("%lf\n", *(double*)(any.data));
            break;
        case STRING:
            printf("%s\n", (char*)(any.data));
            break;
        default:
            break;
    }
}

int main() {
    int i = 10;
    double d = 3.14;
    char str[] = "hello";
    
    Any any1 = {&i, INT};
    Any any2 = {&d, DOUBLE};
    Any any3 = {str, STRING};
    
    printData(any1);
    printData(any2);
    printData(any3);
    
    return 0;
}

在上面的代码中，定义了一个Any结构体，包含一个void*类型的data成员和一个DataType类型的type成员。printData函数使用Any作为参数，根据type的值来打印不同类型的数据。在main函数中，将int、double、string类型的数据转换成Any类型，并传入printData函数中，实现对不同类型数据的打印操作。

c语言实现搜索泛型代码

c语言是一种面向过程的编程语言，不像某些面向对象的语言那样内置了泛型的概念，但我们可以通过一些技巧来实现搜索泛型代码。

一种常见的方法是使用void指针作为参数，这样可以接收任意类型的数据。我们可以将待搜索的元素转换为void指针，并通过回调函数比较元素是否满足搜索条件。以下是一个简单的示例：

#include <stdio.h>

typedef struct {
    int id;
    char name[20];
} Student;

int compareInt(const void* a, const void* b) {
    int* pa = (int*)a;
    int* pb = (int*)b;
    return *pa - *pb;
}

int compareString(const void* a, const void* b) {
    char** pa = (char**)a;
    char** pb = (char**)b;
    return strcmp(*pa, *pb);
}

int compareStudent(const void* a, const void* b) {
    Student* sa = (Student*)a;
    Student* sb = (Student*)b;
    return sa->id - sb->id;
}

void* search(const void* array, int size, const void* target, int (*compare)(const void*, const void*)) {
    for(int i = 0; i < size; i++) {
        const void* current = (char*)array + i * size;  // 根据实际类型大小计算当前元素的指针
        if(compare(current, target) == 0) {
            return (void*)current;
        }
    }
    return NULL;
}

int main() {
    int intArray[] = {1, 2, 3, 4, 5};
    int intTarget = 3;
    int* intResult = (int*)search(intArray, sizeof(int), &intTarget, compareInt);
    printf("Int result: %d\n", *intResult);

    char* stringArray[] = {"apple", "banana", "cherry", "grape"};
    char* stringTarget = "cherry";
    char** stringResult = (char**)search(stringArray, sizeof(char*), &stringTarget, compareString);
    printf("String result: %s\n", *stringResult);
    
    Student studentArray[] = {{1, "Tom"}, {2, "Jerry"}, {3, "Alice"}};
    Student studentTarget = {2, "Jerry"};
    Student* studentResult = (Student*)search(studentArray, sizeof(Student), &studentTarget, compareStudent);
    printf("Student result: id=%d, name=%s\n", studentResult->id, studentResult->name);

    return 0;
}

在搜索函数中，我们通过计算偏移量来获取当前元素的指针，然后通过调用回调函数来比较元素。如果找到满足条件的元素，就返回该元素的地址，否则返回NULL。

这样我们就可以通过search函数来搜索不同类型的数组和元素了。当我们需要搜索其他类型的数据时，只需编写相应的compare函数即可。

这只是一个简单的示例，实际上，泛型代码的实现可以更加复杂和灵活。