函数形参可变

函数形参可变

---

1. 使用 void* 指针和类型标识符

通过使用 void* 指针来表示任意类型的数据，并使用类型标识符来区分不同的数据类型。函数内部根据类型标识符来处理不同的结构体数据。对于未使用的形参，可以简单地忽略它们。

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

typedef struct {
    int intValue;
} IntData;

typedef struct {
    float floatValue;
} FloatData;

typedef struct {
    char strValue[20];
} StringData;

typedef enum {
    TYPE_INT,
    TYPE_FLOAT,
    TYPE_STRING
} DataType;

void processData(void *data, DataType type, int unusedParam) {
    switch (type) {
        case TYPE_INT:
            printf("Int value: %d\n", ((IntData *)data)->intValue);
            break;
        case TYPE_FLOAT:
            printf("Float value: %f\n", ((FloatData *)data)->floatValue);
            break;
        case TYPE_STRING:
            printf("String value: %s\n", ((StringData *)data)->strValue);
            break;
        default:
            printf("Unknown type\n");
            break;
    }
    // unusedParam is not used in this function
}

int main() {
    IntData intData = {10};
    FloatData floatData = {3.14};
    StringData stringData;
    snprintf(stringData.strValue, sizeof(stringData.strValue), "Hello, world!");

    processData(&intData, TYPE_INT, 0);
    processData(&floatData, TYPE_FLOAT, 0);
    processData(&stringData, TYPE_STRING, 0);

    return 0;
}

2. 使用可变参数列表 (stdarg.h)

使用可变参数列表来处理不同数量和类型的参数。虽然这增加了代码的复杂性，但它提供了极大的灵活性，允许传递不同数量和类型的参数。

e#include <stdio.h>
#include <stdarg.h>

typedef struct {
    int intValue;
} IntData;

typedef struct {
    float floatValue;
} FloatData;

typedef struct {
    char strValue[20];
} StringData;

typedef enum {
    TYPE_INT,
    TYPE_FLOAT,
    TYPE_STRING
} DataType;

void processData(DataType type, ...) {
    va_list args;
    va_start(args, type);

    switch (type) {
        case TYPE_INT: {
            IntData *intData = va_arg(args, IntData *);
            printf("Int value: %d\n", intData->intValue);
            break;
        }
        case TYPE_FLOAT: {
            FloatData *floatData = va_arg(args, FloatData *);
            printf("Float value: %f\n", floatData->floatValue);
            break;
        }
        case TYPE_STRING: {
            StringData *stringData = va_arg(args, StringData *);
            printf("String value: %s\n", stringData->strValue);
            break;
        }
        default:
            printf("Unknown type\n");
            break;
    }

    va_end(args);
}

int main() {
    IntData intData = {10};
    FloatData floatData = {3.14};
    StringData stringData;
    snprintf(stringData.strValue, sizeof(stringData.strValue), "Hello, world!");

    processData(TYPE_INT, &intData);
    processData(TYPE_FLOAT, &floatData);
    processData(TYPE_STRING, &stringData);

    return 0;
}

3. 使用函数指针

定义处理不同数据类型的函数，并使用函数指针来调用相应的处理函数。未使用的参数可以简单地忽略。

#include <stdio.h>

typedef struct {
    int intValue;
} IntData;

typedef struct {
    float floatValue;
} FloatData;

typedef struct {
    char strValue[20];
} StringData;

void processIntData(IntData *data, int unusedParam) {
    printf("Int value: %d\n", data->intValue);
    // unusedParam is not used in this function
}

void processFloatData(FloatData *data, int unusedParam) {
    printf("Float value: %f\n", data->floatValue);
    // unusedParam is not used in this function
}

void processStringData(StringData *data, int unusedParam) {
    printf("String value: %s\n", data->strValue);
    // unusedParam is not used in this function
}

typedef void (*ProcessDataFunc)(void *, int);

void processData(void *data, ProcessDataFunc func, int unusedParam) {
    func(data, unusedParam);
}

int main() {
    IntData intData = {10};
    FloatData floatData = {3.14};
    StringData stringData;
    snprintf(stringData.strValue, sizeof(stringData.strValue), "Hello, world!");

    processData(&intData, (ProcessDataFunc)processIntData, 0);
    processData(&floatData, (ProcessDataFunc)processFloatData, 0);
    processData(&stringData, (ProcessDataFunc)processStringData, 0);

    return 0;
}

总结

为了在函数中处理不同的结构体数据，可以使用 void* 指针和类型标识符、可变参数列表、或函数指针。这些方法允许定义灵活的函数接口，可以处理不同类型和数量的参数，未使用的参数可以简单地忽略。这种设计提高了代码的灵活性和通用性。