Get the pointer of struct calling function - c

Question

For the current project I cannot use C++ (unfortunately), only pure C, and Im having the following problem:
I got 3 distinctive struct that need to call the same function name, and I feel its more elegant the way it is below instead of creating 3 different function for the different type, like I feel its easier to maintain. How can I get the pointer that call the function? Basically what I'm trying to reproduce is basically similar as "this" in C++ or self (in Obj-C), is there anyway I can do that in plain C?
[ test.h ]
enum
{
TYPE_A = 0,
TYPE_B = 1,
TYPE_C = 2
};
typedef struct
{
char type;
void ( *GetType )( void );
// Some other data different than the other struct
}A;
typedef struct
{
char type;
void ( *GetType )( void );
/* Some other data different than the other struct */
}B;
typedef struct
{
char type;
void ( *GetType )( void );
// Some other data different than the other struct
} C;
A *create_a( void );
B *create_b( void );
C *create_c( void );
void GetType( void );
[ test.c ]
A *create_a( void )
{
A *a = ( A * ) calloc( 1, sizeof( A ) );
a->type = TYPE_A;
a->GetType = GetType;
return a;
}
B *create_b( void )
{
B *b = ( B * ) calloc( 1, sizeof( B ) );
b->type = TYPE_B;
b->GetType = GetType;
return b;
}
C *create_c( void )
{
C *c = ( C * ) calloc( 1, sizeof( C ) );
c->type = TYPE_C;
c->GetType = GetType;
return c;
}
void GetType( void )
{
printf("How to get the pointer that call this function to retrieve the type?");
}
[ main.c ]
int main (int argc, const char * argv[])
{
A *a = create_a();
B *b = create_b();
C *c = create_c();
a->GetType();
b->GetType();
c->GetType();
return 0;
}

Answer 1

The traditional way to do this kind of thing (eg in the UNIX kernel) is by using a #define for syntactic sugar:
#define GET_TYPE(X) ((X)->GetType((X)))
Of course if there are more arguments it passes those as well. The function pointers are usually collected in one static "ops" structure which is assigned on creation (instead of every individual function pointer). Each ops vector has a corresponding collection of #defines.

Answer 2

Pass this as a normal parameter (first, to be conventional):
void GetType(void *this);
...
GetType(a); // instead of C++-style a->GetType
It'd be better to have some "base class" (including "int type" field), in this case pointer will be "struct Base *this", not a "void *this").
Personally I always go this way. You can add prefix for a functions of some "class" (for example, Cl1_GetType). This is the way of OO-programming in C. "Real virtual functions" through function pointers could also be used, but it's not such common case.

Answer 3

"this" should be given as a parameter to GetType(). That's how object methods are actually implemented under the hood. Moreover, since GetType should be able to interact with all kind of struct - the structs should have a similar "base class". for example:
#include "stdio.h"
typedef enum
{
TYPE_A = 0,
TYPE_B = 1,
TYPE_C = 2
} my_class_type;
typedef struct
{
char type;
my_class_type ( *GetType )( void* );
}my_base;
my_class_type my_base_GetType( void* my_base_ptr)
{
return ((my_base*)my_base_ptr)->type;
}
typedef struct
{
my_base base;
// Some other data different than the other struct
}A;
typedef struct
{
my_base base;
/* Some other data different than the other struct */
}B;
typedef struct
{
my_base base;
// Some other data different than the other struct
}C;
A *create_a( void )
{
A *a = ( A * ) calloc( 1, sizeof( A ) );
a->base.type = TYPE_A;
a->base.GetType = my_base_GetType;
return a;
}
B *create_b( void )
{
B *b = ( B * ) calloc( 1, sizeof( B ) );
b->base.type = TYPE_B;
b->base.GetType = my_base_GetType;
return b;
}
C *create_c( void )
{
C *c = ( C * ) calloc( 1, sizeof( C ) );
c->base.type = TYPE_C;
c->base.GetType = my_base_GetType;
return c;
}
int main(int argc, char* argv[])
{
A *a = create_a();
B *b = create_b();
C *c = create_c();
printf("%d\n",a->base.GetType(a));
printf("%d\n",b->base.GetType(b));
printf("%d\n",c->base.GetType(c));
return 0;
}
This example implements inheritance and polymorphism. All structs share the same base core and if you want to override GetType() you just change the pointer in base. you can hold a pointer to my_base and dynamically resolve the type.

Answer 4

From what i understood of your question is: "You just want to obtain the value of the type field in the structure in GetType function". Is this right? If yes, you can do it this way:
enum
{
TYPE_A = 0,
TYPE_B = 1,
TYPE_C = 2
};
typedef struct
{
char type;
// Some other data different than the other struct
}A;
typedef struct
{
char type;
/* Some other data different than the other struct */
}B;
typedef struct
{
char type;
// Some other data different than the other struct
} C;
A *create_a( void );
B *create_b( void );
C *create_c( void );
void GetType( void * );
[test.c]
A *create_a( void )
{
A *a = ( A * ) calloc( 1, sizeof( A ) );
a->type = TYPE_A;
return a;
}
B *create_b( void )
{
B *b = ( B * ) calloc( 1, sizeof( B ) );
b->type = TYPE_B;
return b;
}
C *create_c( void )
{
C *c = ( C * ) calloc( 1, sizeof( C ) );
c->type = TYPE_C;
return c;
}
#define GetType(x) (x->type)
[main.c]
int main (int argc, const char * argv[])
{
A *a = create_a();
B *b = create_b();
C *c = create_c();
GetType(a);
GetType(b);
GetType(c);
return 0;
}
Hope this answers your question.