sizeof(MPEGLAYER3WAVEFORMAT)

[CPP freshman]

MPEGLAYER3WAVEFORMAT is defined by:

typedef struct mpeglayer3waveformat_tag {
  WAVEFORMATEX wfx;
  WORD         wID;
  DWORD        fdwFlags;
  WORD         nBlockSize;
  WORD         nFramesPerBlock;
  WORD         nCodecDelay;
} MPEGLAYER3WAVEFORMAT, *LPMPEGLAYER3WAVEFORMAT;

The size should be 30. However,

    cout<<"size of MP3 format: "<<sizeof(MPEGLAYER3WAVEFORMAT)<<endl;
cout<<actual size: <<sizeof(WAVEFORMATEX)+ sizeof(WORD)+ \ 
sizeof(DWORD)+ sizeof(WORD)+ sizeof(WORD)+ sizeof(WORD)<<endl;

produces:
size of MP3 format: 32
actual size: 30

Why 32 and 30? They are not equal?

[CPP freshman]

I tried the following test:

    struct mp3{//exact copy of MPEGLAYER3WAVEFORMAT 
      WAVEFORMATEX wfx;
      WORD         wID;
      DWORD        fdwFlags;
      WORD         nBlockSize;
      WORD         nFramesPerBlock;
      WORD         nCodecDelay;
    }; 
    cout<<"mp3: "<<sizeof(mp3)<<endl;

produces:
mp3: 32

But, if we removes the last WORD element nCodecDelay,

   struct mp3_short{//
      WAVEFORMATEX wfx;
      WORD         wID;
      DWORD        fdwFlags;
      WORD         nBlockSize;
      WORD         nFramesPerBlock;
    }; 
 
  cout<<"mp3 shortened: "<<sizeof(mp3_short)<<endl; 

produces:
mp3 shortened: 28

If the previous output 32 is correct, this should be 30, right? Since only a WORD of size 2 has been removed!

[weaknessforcats]

I believe you are encountering pad bytes inserted by the compiler to align your struct members on int boundaries.

For example, thus struct:

struct MyStruct
{
   char data1;
      int data3;
};

has a sizeof 8 bytes. data1 is on an int boundary so to make data3 also on an int boundary three pad bytes are added between data1 and data3. So if you do this:

struct MyStruct
{
   char data1;
   unsigned char pad1;
   unsigned char pad2;
   unsigned char pad3;
      int data3;
};

you will see that the sizeof the struct is still 8 bytes.

It's useful to know this because pad bytes are not written making it harder to locate your data in a file that you read back in.

[CPP freshman]

Thanks for you reply.

You're right, and I used your example to write to a file:

    struct MyStruct
    {
      char data1;
      int data3;
    } ms;
    ms.data1='a';
    ms.data3=0xffffffff;
    FILE*target=fopen("tmp",wb);
    int i=0;
    fwrite(&ms,sizeof(ms),1,target);
    fclose(target);

and then I checked the file by
xxd tmp
It produces:
0000000: 6122 2a00 ffff ffff a"*.....
The bold part is the data we generated, the remaining part is garbage.

I guess that's fine if we use the programs compiled by the same compiler to retrieve information from this file.

But what if the programs are generated by compiler without padding? Anyway to avoid this?

[CPP freshman]

Added

#pragma pack(1)

to fix the problem.

And I am not sure if this is the right choice ...

[Banfa]

Adding #pragma pack(1) is not really the right choice because if it gets changed you suddenly can't read any of your old files. The packing of structures is done to allow the program to be efficient. Many processors can not access multi byte integers (like WORD and DWORD) from odd addresses or even for 4 byte integers from addresses that are not a multiple of 4.

That means for your packed structure is if you end up with a WORD or DWORD not starting at the correct alignment instead of just reading the value directly the compiler has to generate code to individually load each byte of the integer and reconstruct it in a register. Obviously (I think) this has a really big effect on program performance.

So the correct way to save a structure to a file is to decided what format the file is to have, what is going in each byte of the file, where each member of the structure will be stored and the write out the individual members of the structure rather than write the whole structure in 1 go. To make sure it is always done the same way and that it is read back correctly create functions to read and write the structure.