I have several structures, such as the following:

typedef struct MainStruct
{
   SpriteRec   spriteRec;

   short       oldRow;
   short       oldCol;
   short       direction;

typedef struct Enemy1Struct
{
   SpriteRec   spriteRec;

   short       direction;

typedef struct FallingStruct
{
   SpriteRec   spriteRec;

   short       startRow;
   short       fallDelay;
   short       tileID;
   short       bombTimer;
   short       life;

I want to be able to declare a new structure that is large enough to hold
the largest of any of those structures, but *not* including the SpriteRec.
Normally, you'd do something like a union for this, but a union would
include the SpriteRec:

typedef union SpriteUnion
{
   MainStruct     mainStruct;
   Enemy1Struct   enemy1Struct;
   FallingStruct  fallingStruct;

Is there some way to declare some sort of a structure that is
sizeof(SpriteUnion) - sizeof(SpriteRec)? It seems this would be possible
in assembly language, but so far I haven't found any way to do it in C.

-Vern

--
Replace the REPLACEME in my email address with Jensen to reply.

Visit the SpriteWorld web page: http://www.*-*-*.com/
--

You could do:

typedef MyStruct {
        char data[sizeof(SpriteUnion) - sizeof(SpriteRec)];

I'm not sure how useful this would be, though.  I'm having trouble
understanding why you want to do this.  I suspect there may be a
more elegant solution to your problem if I understood it better.

peter
--

Well, if it was smaller than the whole thing, you couldn't really FIT an
enemy1Struct inside, huh?  So, you have to add an extra level of
granularity to your structs.  Make each of the non-SpriteRec parts of
each struct their own structs, and then union them together.  (I've
removed redundant Struct words for clarity):

        typedef struct FallingOnly { ... };
        typedef struct Enemy1Only  { ... };

        typedef struct Falling { Sprite s; FallingOnly fo };
        typedef struct Enemy1  { Sprite s; Eenmy1Only  e1o };

        typedef union SpriteUnion { FallingOnly fo; Enemy1Only e1o };

        SpriteUnion u;
        Falling f;
        u.fo = f.fo;      /* stuff the non-sprite stuff into the union */

I can't think of why you would want to do this, though.  Any
explanation?
Scott
--

[snip]

to malloc()?  If so, try this.

I'm not sure if this is portable (structure padding come to mind as a
possible portability-killer), but why not something like:

typedef union foo {
        MainStruct m;
        Enemy1Struct e;
        FallingStruct f;

ptr = malloc(sizeof(bar) - sizeof(SpriteRec));

If that's not what you were looking for, then can you clarify?

-- DN
--