Typecasting portability in C

[chadsspameateremail]

What I am trying to do is implement polymorphism in C. Why? This is to
build a library which will be a C library and callable from C.
However, I want to have polymorphic functions which are callable from
outside the library. Specifically I want to have functions like Show()
which will take a pointer to an object and do something different
based on the type object passed to it. Of course this would be trival
in C++ but I'm restricted to use C.

OK so my current idea for something like the polymophic Show()
routine: Since all the objects are created inside the library I can
attach to each object a signature. The Show() routine would accept a
void* but then typecast it and get the signature out of the object.
Since each object is a structure (and created and defined inside the
library) I would append this signature to the front of each and every
struct. The signature would likely be something like an integer. So
each and every object would look like:

struct SomeObjectType {
int signature;
.....//bunch other other stuff
};

The Show() routine would typecast the void* to the following
structure:

struct {
int signature;
}

So my Show() and similar polymorphic routines would get the object and
ultimatly open it and look at the first field which would always be
the signature object. Based on what it found there (the value of
signature) it would do something different. Makes sense? I hope so.

So I have implemented some prototype code on this and it does work but
what I was wondering is how portable is this? The structure's first
item (the signature) will always be the same this I can guarantee but
again what about portability. Really I'm converting from a pointer to
one type, to a void*, then to a pointer to another type (for signature
extraction). Certainly the first object in the final structure will be
the same as the first object in the original structure and the same
size as well. But does that make it portable?

Is this legal C as defined by the standard? Is this going to work
across platforms? I hope you see my dilemma the code appears to work
on my system. The code below happily prints the expected output of
112. but I don't know if it's guaranteed to work everywhere and how
portable the library functions will be because of it?

Is this defined in any C standard anywhere what will happen and what
about general portability concerns?

In the example below I defined a structure CouldBeAnything and filled
it with a long and a char but really not only that structure but
anything after that initial signature integer will be different from
object to object. The only thing I can guarantee is that the first
item will be that signature integer on each object. Will this
conversion work? Is it portable? It works on my machine but does that
mean it will work in general? Thank you. :)

---
//On the code below when run on my machine it happily prints out 112
//No warnings are given by the gcc complier with warning flag -Wall

#include <stdio.h>

//This structure could contain anything
struct CouldBeAnything
{
long ThisTimeItsALon g;
char AndAChar;
};

struct MinimalStructur e
{
int Signature;
};
struct LargerStructure
{
int Signature;
struct CouldBeAnything SomeStructure;
};

int main ()
{
struct LargerStructure SomeLargeStruct ure;

SomeLargeStruct ure.Signature = 112;
SomeLargeStruct ure.SomeStructu re.ThisTimeItsA Long = 1;
SomeLargeStruct ure.SomeStructu re.AndAChar = 'a';

struct MinimalStructur e* Minimal = ( struct MinimalStructur e* )
&SomeLargeStruc ture;

printf( "Signature = %d\n", Minimal->Signature );
return 0;
}

[Yevgen Muntyan]

ch************* ****@yahoo.com wrote:

What I am trying to do is implement polymorphism in C. Why? This is to
build a library which will be a C library and callable from C.
However, I want to have polymorphic functions which are callable from
outside the library. Specifically I want to have functions like Show()
which will take a pointer to an object and do something different
based on the type object passed to it. Of course this would be trival
in C++ but I'm restricted to use C.

OK so my current idea for something like the polymophic Show()
routine: Since all the objects are created inside the library I can
attach to each object a signature. The Show() routine would accept a
void* but then typecast it and get the signature out of the object.
Since each object is a structure (and created and defined inside the
library) I would append this signature to the front of each and every
struct. The signature would likely be something like an integer. So
each and every object would look like:

struct SomeObjectType {
int signature;
....//bunch other other stuff
};

The Show() routine would typecast the void* to the following
structure:

struct {
int signature;
}

So my Show() and similar polymorphic routines would get the object and
ultimatly open it and look at the first field which would always be
the signature object. Based on what it found there (the value of
signature) it would do something different. Makes sense? I hope so.

As you were told elsewhere, it won't work. But you can do same
thing with

struct Base {
int signature;
};

struct Child {
struct Base base;
long something;
};

It will require a cast if you got Child* and want Base members, but
it's not really high price.

Yevgen

[Laurent Deniau]

Thad Smith wrote:

Eric Sosman wrote:

>Thad Smith wrote:

>>ch************* ****@yahoo.com wrote:

What I am trying to do is implement polymorphism in C.

...

I would append this signature to the front of each and every struct.
The signature would likely be something like an integer. So each and
every object would look like:

struct SomeObjectType {
int signature;
....//bunch other other stuff
};

The Show() routine would typecast the void* to the following structure:

struct {
int signature;
}

...

Is this legal C as defined by the standard?
Yes. If the initial sequence of two structures match, the members in
the initial sequence can be accessed through either structure type.

... provided the two structs are members of the same union.
A compiler would need to be awfully smart and awfully perverse
to arrange things so the presence of the union made any difference,
but the formal guarantee has union membership ("Look for ... the
union label") as a precondition.

Thanks, Eric for that important correction.

As far as perverse goes, here's a possibility:

An implementation has an alignment requirement that an int be on an
4-byte boundary and single byte objects are accessed faster on even
addresses than odd addresses.

Given
struct S1 {
char a,b;
} s1;

struct S2 {
char a,b;
int c;
} s2;

The implementation may choose to implement S1 with no padding bytes, and
S2 with a single padding byte between a and b, and another between b and
c. That arrangement gives faster accesss to s2.b, while keeping the
size of struct S1 to a minimum.

This is the same point as my answer to Harald van Dijk. So the trick is
to put an anonymous 0 length bit field after the matching part:

struct S1 {
char a,b;
};

struct S2 {
char a,b;
int :0;
int c;
};

struct S3 {
struct S1 s;
int c;
};

Then S1, S2 and S3 should have compatible layout on the common part
whatever the field are in this part. This is what OOC-2.0 does and I
haven't seen problem with that. I don't know if anonymous 0 length bit
field was created for this purpose, but it works fine.

a+, ld.

[Jamie Boy]

OK so my current idea for something like the polymophic Show()
routine: Since all the objects are created inside the library I can
attach to each object a signature. The Show() routine would accept a
void* but then typecast it and get the signature out of the object.
Since each object is a structure (and created and defined inside the
library) I would append this signature to the front of each and every
struct. The signature would likely be something like an integer. So
each and every object would look like:

struct SomeObjectType {
int signature;
....//bunch other other stuff
};

V-Table is what you want. Something like:

typedef struct VTableForVehicl e {
void (*StartEngine)( void);
void (*Accelerate)(u nsigned);
void (*Brake)(unsign ed);
} VTableForVehicl e;

Provide definitions for each of the functions for each kind of vehicle:

void Car_StartEngine (void) { /* Code */ }
void Car_Accelerate( unsigned) { /* Code */ }
void Car_Brake(unsig ned) { /* Code */ }
void Bike_StartEngin e(void) { /* Code */ }
void Bike_Accelerate (unsigned) { /* Code */ }
void Bike_Brake(unsi gned) { /* Code */ }

Then populate global const v-table objects for each kind of vehicle:

VTableForVehicl e const
vtab_car = {Car_StartEngin e,Car_Accelerat e,Car_Brake},
vtab_bike = {Bike_StartEngi ne,Bike_Acceler ate,Bike_Brake} ;

Now put a V-Table pointer at the beginning of each vehicle object, then put
a vehicle object inside every car, every bike:

typedef struct Vehicle { VTableForVehicl e const *pvtab; } Vehicle;

typedef struct Car { Vehicle vehicle; } Car;
typedef struct Bike { Vehicle vehicle; } Bike;

And "initialise " it as follows:

Car obj = { {vtab_car} };

Then polymorphism can be exploited as follows:

void FuncWhichTakesA Vehicle(Vehicle *const p)
{
p->Accelerate() ;
}

Bit of a snappy explanation but you get the idea.

--
~/JB\~