Receive pointer to different structs in different calls as an argument (or something like that)

Question

For example, assume I have something like this:

typedef struct one
{
    int data;
    int dogs;
}One;

typedef struct two
{
    int data;
    int birds;
}Two;

typedef struct three
{
    int data;
    int cats;
}Three;

void swapData(???* elem1, ???* elem2) //<- the problem is here
{
    int temp = elem1->data;
    elem1->data = elem2->data;
    elem2->data = temp;
}

int main()
{
    One dog;
    Two bird;
    Three cat;

    dog.data = 1;
    bird.data = 2;
    cat.data = 3;

    swapData(&dog, &cat);
    swapData(&dog, &bird);
    swapData(&bird, &cat);
    return 0;
}

What do I have to put in place of the ??? for the function to accept pointers to either One, Two or Three structs as arguments? I tried void but then I can't access the structs' fields...

Answer 1

If you always define the data first in each struct, and data is always an int, then you can do something like this:

void swapData(void* elem1, void* elem2) //<- the problem is here
{
    int* e1 = (int*) elem1;
    int* e2 = (int*) elem2;
    int temp = e1[0];
    e1[0] = e2[0];
    e2[0] = temp;
}

the reason this works is because when you pass a void *, you get memory of size sizeof(One) or whatever you put in. since the data is first, we can just pretend that you passed in an array of integers, and take the first one. If you had a more complicated structure, you could build a struct where the first few elements are the same types as any struct you might pass in. this way you could manipulate multiple objects. that would look something like this:

typedef struct {
    int data;
    char * name;
    ...
} complicated;

typedef struct {
    int data;
    char * name;
    int something_else;
} simple;

typedef struct { // least common denominator
    int data;
    char * name;
} common;

void swap(void * e1, void* e2){
    common* c1 = (common*) e1;
    common* c2 = (common*) e2;
    int tmp = c1->data;
    char * tmpn = c1->name;
    c1->data = c2->data;
    c1->name = c2->name;
    c2->data = tmp;
    c2->name = tmp;
}

hope this makes sense.

Answer 2

You can't do that, you have ti write 3 separate functions to achieve this...

void swapData13(one *elem1, three*elem2) 
{
    int temp = elem1->data;
    elem1->data = elem2->data;
    elem2->data = temp;
}

void swapData12(one *elem1, two*elem2)
{
    int temp = elem1->data;
    elem1->data = elem2->data;
    elem2->data = temp;
}

void swapData23(two *elem1, three*elem2) 
{
    int temp = elem1->data;
    elem1->data = elem2->data;
    elem2->data = temp;
}

Also the way you are passing parameter in main is wrong... You can do...

swapData13(&dog, &cat);
swapData12(&dog, &bird);
swapData23(&bird, &cat);

Out of curiosity, what do you want to achieve by writing such code?

Answer 3

There are several options available. Among them:

• Switch to C++. You can then derive your three structs from a common base struct that includes the data member. Or use classes instead of structs and do the same thing. (This isn't as unhelpful as it might sound -- most C compilers these days also compile C++, and switching may be as simple as changing a file extension or compiler flag.)

• Use a single struct containing a union for the second members. That way, you have only one type to deal with.

• Use a single struct without the union and name the second member animals.

• Create a struct Data that holds the data member, and then "piggyback" any other members onto that. That is, make sure that an instance of the Data struct is the very first member of One, Two, and Three. Then use type struct Data * when you only want to refer to the common part.

• Look into ways to simulate OO-style polymorphism in C. Warning: it's not pretty.

• Pass a pointer to the data member in each struct rather than a pointer to the entire struct.

Here's an example of that last strategy:

void swapData(int* data1, int* data2)
{
    int temp = *data1;
    *data1 = *data2;
    *data2 = temp;
}

// call it like this:
swapData(&(dog->data), &(cat->data));

Any way you slice it, the swapData() function needs to know what it's dealing with. Plain old C doesn't provide inheritance polymorphism, so there's not a straightforward way to create a single base type that encompasses all three of your structs. So, you have to resort to passing just part of a struct, or casting the struct to a simpler type, etc. Since the data member is actually the first item in each of the structs, you can use the swapData() I provided above but simplify the call a little bit:

swapData((int*)dog, (int*)cat);

That's sneaky, though, and harder to understand (or maybe easier to misunderstand) even though it's shorter.

Answer 4

Create another data structure like this:

struct typee{
    int ele1;
    int ele2;
}id;

While filling elements:

id.ele1 = DOGS; // #define DOGS 1
id.ele2 = CATS; // #define CATS 2

Function definition:

void swapData(void* elem1, void* elem2, struct typee id) //<- addind new argument
{
      //using id, type cast the ele1 and ele2 to theier structures 
      ...

}

My suggestion:

typedef struct generic    //only One structure at all
{
    int data;
    int specie;
}all;

main()
{
    struct generic dog;
    struct generic cat;

    ....   // filling structure elements
    swapData(&dog, &cat);
    ...
}

Function definition:

void swapData(struct generic * elem1, struct generic* elem2)
{
    int temp = elem1->data;
    elem1->data = elem2->data;
    elem2->data = temp;
}

Answer 5

To be clear I dont understand exact need of this, But if there are only 3 cases, then you can encode them something like this,

void swapData(void* elem1,  void* elem2, int type) 
{
    if( type == 0 )         //type == 0 corresponds to comparison of One & Two
    {
        One *e1 = (One*)elem1;
        Two *e2 = (Two*)elem2;
        int temp = e1->data;
        e1->data = e2->data;
        e2->data = temp;
    }
    else if(type == 1)      //type == 1 corresponds to comparison of One & Three
    {
        One *e1 = (One*)elem1;
        Three *e2 = (Three*)elem2;
        int temp = e1->data;
        e1->data = e2->data;
        e2->data = temp;
    }
    else
    {
        //type == 2 corresponds to comparison of Two & Three
    }

}

Call from the main function using third argument

swapData(&dog,&bird,0);

This method is not that efficient for higher cases