是否可以创建一个可以使用不同结构操作的函数（在 C 中）？

Question

我正在寻找用 C 语言创建一个函数，该函数允许我接收不同的结构类型作为参数。 例如，如果我创建 3 个不同的结构

struct a{
    struct datatype0{
         char test1[10];
    }datatype;
    struct a *next;
};

struct b{
    struct datatype1{
        int test1;
        char test2[20];
        int test3;
    }datatype;
    struct b *next;
};

struct c{
    struct datatype2{
        char test1;
        char test2;
        float test3;
        int test4;
        int test5;
    }datatype;
    struct c *next;
};

我想创建一个可以接收这三种不同结构之一作为参数的函数，所以我只能调用它来初始化第一种、第二种或第三种结构：

void function("---")//<-- inside the brackets i need to insert a parameter that can be struct a, or struct b or struct c.
{
//here for example I can insert the initialize function that have to work with any struct.

}

我尝试使用联合，但我看到我必须为每种结构重新创建初始化函数...我尝试使用 void 指针，但我需要在函数内部强制转换，我需要创建也为每种结构初始化函数...... 有什么想法吗？？

Answer 1

它的长短是：尽可能避免这样做，但要知道，如果你真的需要，可以将不同的结构传递给单个函数。

可能最简单的方法是创建一个包装结构，其中包含 2 个成员：一个联合和一个标志，让您知道传递了哪个结构。

typedef enum {
    A,
    B,
    C
} struct_type;

struct _wrapper {
    union {
        struct a A;
        struct b B;
        struct c C;
    };
    struct_type flag;
};

void my_function(struct _wrapper *data)
{
    switch (data->flag)
    {
        case A:
            struct a val = data.A;
            //do stuff with A
            break;
        case B:
            struct b val = data.B;
            break;
        case C:
            struct c val = data.C;
            //...
            break;
    }
}

另一种选择，虽然它被认为是不好的做法，并且你最终会后悔的事情是依赖于这样一个事实，即任何结构的第一个成员的偏移量都保证为 0。你可以将指针转换为任何struct 指向其第一个成员的指针。如果所有结构的第一个成员都兼容，您可以依赖它（风险自负）。
利用这一点的一种方法是将函数指针设置为第一个成员，或者设置一个枚举字段，您可以将其用作标识结构的标志：

struct a {
    void (*common_member)();//
    /** other members **/
};
struct b {
    void (*common_member)();//needn't be the same name though
    /** other members **/
};

然后：

void my_func(void *data)
{//void pointer
    ((void (*)(void *))data)(data);//cast void *data to function pointer, and pass itself as an argument
}

如果结构被正确初始化，并且成员指向正确的函数，这可以工作，但是这实在是太多了。

使用枚举作为第一个成员的风险略小，但仍不推荐。这是一种函数指针和联合方法的组合

void my_func(void *data)
{
    //cast void * to struct_type *, dereference AFTER the cast
    //because you can't dereference a void *
    switch(*((struct_type *) data))
    {
        case A: /* stuff */ break;
        case B: /* struct b */ break;
    }
}

总而言之，使用第一种方法。不要使用函数指针成员，并承认第三种方法是什么：是的，您不需要包装结构，但它并不比原始方法（函数指针）安全得多，而且不比第一种方法（使用联合）。

底线：结构和联合是要走的路

Answer 2

它在某种程度上有效。但例如，如果我想创建一个函数，例如：

typedef union elemento{
    struct a A;
    struct b B;
    struct c C;
}elemento;

void inserimentoOrdinato(elemento dausare){
    struct b prova;
    prova.datatype.test1 = 3;
    strcpy(prova.datatype.test2,"TESTA");
    prova.datatype.test3 = 200;
    prova.next = (struct a*)malloc(sizeof(struct a));
    dausare.B = prova;
}

对于不同类型的结构，我需要使用“dausare.B”或“dausare.C”。它不知道必须使用联合的哪个部分。我说得对吗？谢谢！

Answer 3

答案是泛型编程和函数指针：

**void * 可以是指向任何结构的指针

声明部分：

typedef void *Initializer(void* obj);//since every struct has its own fields to initialize

void function(void * obj, Initializer init)
{
    init(obj);
}

用法：

void InitA(void* a_void)
{
    struct a* a  = (struct a*) a_void;
    //init a feilds
    a->next = NULL;
}

void InitB(void* b_void)
{
    struct b* b  = (struct b*) b_void;
    //init b feilds
    b->next = NULL;
}

void InitC(void* c_void)
{
    struct c* c  = (struct c*) c_void;
    //init a feilds
    c->next = NULL;
}

int main()
{
    struct a a;
    struct b b;
    struct c c;

    Init(&a,InitA);
    Init(&b,InitB);
    Init(&c, initC);

    return 0;
}

***请记住，如果每个结构具有要初始化的相同字段，则不必为每个结构构建不同的函数。