Tupe forviring

Der er ingen garanti for at en short fylder 2 byte eller en int 4.
Der findes faktisk compilere der har 32 bit char, short og int, her fylder de alle 1 byte.
Man kan også have bytes på 11 bit.
På mange 16 bit platforme er int og short 16 bit, mens long er 32 bit.
Men med mingw en en char 8 bit, en byte
short er 16 bit, 2 byte
int er lige som long 32 bit, 4 bytes.

Og det fylder de også i virkeligheden:

#include <iostream>

struct Short
{
   short S1;
   short S2;
};

struct Int
{
   int I1;
   int I2;
};

int main()
{
   std::cout << sizeof(short) << ", " << sizeof(int) << std::endl;
   std::cout << sizeof(Short) << ", " << sizeof(Int) << std::endl;
}

Men bemærk at padding kan gøre at short's kommer til at fylde som en int.

Denne struct vil ofte fylde 16 byte:

struct Short
{
   short S1;
   int I1;
   short S2;
   int I2;
};

Hvorimod denne ofte vil fylde 12:

struct Short
{
   int I1;
   short S1;
   short S2;
   int I2;
};

Det er langt fra simpelt. Compileren kan finde på at arrangere hukommelsen totalt mærkeligt, men sikkert af meget gode grunde.
Denne kode:

int main (int argc, char ** argv)
{
    char array[7];
    return 0;
}

...opretter et array på 7 bytes. Det skulle man tro ville blive forstørret til 8 bytes for at overholde 4 bytes alignment. Men følgende assembly blev genereret:

08048368 <main>:
 8048368:   55                      push   %ebp
 8048369:   89 e5                   mov    %esp,%ebp
 804836b:   83 ec 18                sub    $0x18,%esp
...

0x18 er 24 bytes. Jeg har ingen anelse om hvorfor et 7 byte stort array skal fylde 24 bytes, men sådan er det altså åbenbart bare.