Accessing members inside struct with member function? [duplicate] - c

Question

This question already has answers here:
How can I simulate OO-style polymorphism in C?
(13 answers)
Closed 6 years ago.
Suppose I have the following struct
struct Being{
int canFly;
int (*printFlying)();
}
And I want to do something like the following:
int main(){
struct Being * flyingThing = new_flyingThing();
struct Being * thingThatCantFly = new_Thing();
flyingThing->printFlying(); /* "I'm flying!" */
thingThatCantFly->printFlying(); /* "I can't fly!" */
}
It looks like I would need the printFlyingfunction to be able to access the canFly variable in the struct, but I don't know how to do this, or if this is possible.
Is there any way to get my code to do what I want? Thanks!!
I explained in the comments why this question is not a duplicate of the linked one.

Answer 1

C isn't an object-oriented language, so there's no automatic way for a function member to know which structure was used to call it.
Since each structure has its own function pointer, you can get the result you want by having them refer to different functions, which print the appropriate message, instead of getting it from the can_fly member.
int print_flying_thing() {
printf("I'm flying!\n");
}
struct Being *new_flyingThing() {
struct Being *thing = malloc(sizeof(struct Being));
thing->can_fly = 1;
thing->printFlying = print_flying_thing;
return thing;
}
int print_nonflying_thing() {
printf("I can't fly!\n");
}
struct Being *new_Thing() {
struct Being *thing = malloc(sizeof(struct Being));
thing->can_fly = 0;
thing->printFlying = print_nonflying_thing;
return thing;
}

Answer 2

The function pointed to by the printFlying pointer cannot access members of the containing struct Being structure unless it's given a parameter that refers to that structure. (Or it could access the structure in some other way, perhaps via a global variable, but a parameter is the cleanest way.)
Consider, for example, two objects of type struct Being, both having their printFlying pointer pointing to the same function. There's no way that function can tell which of the two objects it's associated with -- because it isn't associated with either of them.
C++ member functions can do that because they're given an implicit pointer parameter, referred to inside the function via the this keyword. C has no such feature.
You could probably create a macro that does something similar, but I doubt it would be worth the effort.
Have you considered just using C++?

Answer 3

For this particular example what you seem to really want is the ability to have a function pointer that points to two different functions, one to implement flying and one that implements not flying.
So the approach I would consider would be something like the following. I have not tried to actually compile this code but the sense of this is correct.
Also in your comments you mentioned about preventing changing the function pointer. You can do something like the following where a const is added to the struct definition for the function pointer and then using a clone of the struct with a cast.
Header file flying.h contents.
typedef struct _TAG_Being {
int (* const printFlying)();
} Being;
Being * new_flyingThing ();
Being * new_Thing();
Implementation or flying.c file.
#include "flying.h"
static int printFlyingThing()
{
printf (" I am a flying thing\n");
return 0;
}
static int printThing()
{
printf (" I am a thing\n");
return 1;
}
// use the same layout and members as Being above.
typedef struct {
int (* printFlying)();
} BeingX;
Being * new_flyingThing ()
{
BeingX *p = malloc(sizeof(BeingX));
p->printFlying = printFlyingThing; // use the flying thing function
{
Being *q = (Being *)p;
return q;
}
}
Being * new_Thing()
{
BeingX *p = malloc(sizeof(BeingX));
p->printFlying = printThing; // use the not flying thing function.
{
Being *q = (Being *)p;
return q;
}
}
Main or using .c file
#include "flying.h"
int main(){
Being * flyingThing = new_flyingThing();
Being * thingThatCantFly = new_Thing();
flyingThing->printFlying(); /* "I'm flying!" */
thingThatCantFly->printFlying(); /* "I can't fly!" */
}
If you have a need to access the actual Being object or variable in the printFlying() function then you will need to pass it as an argument.
For instance:
typedef struct _TAG_Being {
int xx;
int (*printFlying)(struct _TAG_Being *p);
} Being;
Then you would need something like:
Being * flyingThing = new_flyingThing();
flyingThing->printFlying(flyingThing); /* "I'm flying!" */