Help me to understand something...

[crptcblade]

When passing a struct into an API, I've noticed that many have a member that represents the size of the struct in bytes. I was just wondering why that would be needed. Shouldn't the size already be known by the definition of the struct?

[parksie]

Most likely for backwards compatibility. If you pass the size, then a newer function can expect both the old and new structures, and act accordingly

[crptcblade]

Hmmm...*ponders a bit*

Sounds good.

[jim mcnamara]

Parksie has it. But it really relates to MS approach to development of their OS 'families' Consumer windows (9X) is really sixteen bit - all of the api calls are translated 'down' to that environment.

The NT family are actually 32 bit calls.

So if you have code that should run both places there needs to be a way for the api interface (most of the stuff listed as api's are NOT - they merely pass the data to the real internal api - they are wrappers) to figure out what to do with the stuff it's given.

Some native api's that are easy to find are any that start with Rtl
like RtlZeroMemory() (calloc() calls this for example), or RtlMoveMemory().

There are a LOT of native NT api's - in fact, there is a book on the subject:

Gary Nebbet - Windows NT/2000 Native API Reference

[CornedBee]

As a practical example, say you have a struct:
struct SOMETYPE {
DWORD dwSize;
int member;
int thing;
};

sizeof(SOMETYPE) would be 12.

There is a function that takes such a struct as an argument:
void func(SOMETYPE *pST);

In a later header file you exand the struct:
struct SOMETYPE {
DWORD dwSize;
int member;
int thing;
long weebl;
long bob;
};

sizeof(SOMETYPE) would be 20.

The function still has the same prototype, but the code was replaced by newer code in the current DLL.

Now up comes a user with a new version of the DLL but an old version of the header file and writes code using the old SOMETYPE struct, which is passed to the new func in the DLL. (happens all the time)
Normally this would probably result in an access violation or worse in stack corruption. But if you write the new function so it uses the dwSize member it works:

struct OLD_SOMETYPE {
  DWORD dwSize;
  int member;
  int thing;
};

void func(SOMETYPE *pST)
{
  if(pST->dwSize == sizeof(OLD_SOMETYPE)) {
    // old code
  } else if(pST->dwSize == sizeof(SOMETYPE)) {
    // new code
  } else {
    // error: unknown struct size
  }
}