Declaring an array using sizeof

[finalfrontier]

I have the following code:

struct mystruct {
   char fieldA[5];
   char fieldB[7];
};
 
void dosomething(struct mystruct* pms) {
   char content[sizeof(pms->fieldB)];
 
   /* some code... */
 
   memcpy(content, pms->fieldB, sizeof(pms->fieldB));
 
   /* some code... */
}
 
int main(int argc, char** argv) {
   struct mystruct ms;
   char array[sizeof(ms->fieldA)];
 
   /* some code... */
 
   memcpy(array, ms.fieldA, sizeof(ms.fieldA));
 
   /* some code... */
}
 

Is there any problem doing that, even for a C89/90 compiler?


Thanks!

[weaknessforcats]

I have never liked using sizeof for arrays. The reason is that sizeof is used to determine the size of a type and an array is not a type on the stack. An array is a collection of a type.

sizeof gives you the size of the object on the stack. If you define the array on the stack you get the size of the array. However, if you pass the array to a function, what you pass is the address of the array and not the array itself. Do a sizeof the array from inside that function and you get the sizeof the pointer.

I use defensive programming and always keep the number of array elements in a separate struct member.

That said, the code you posted does give the correct array size.

[finalfrontier]

I understood. Thank you for the answer!

One more question: that code is OK because that sizeof is evaluated at compile time and its value never changes... right? I mean, "sizeof(ms.fieldA)" and "sizeof(pms->fieldA)" will always be 5 (the same idea can be applied for "fieldB").

I have to correct a little piece of that code. In the main function, obviously I made a little mistake. Instead of "sizeof(ms->fieldA)", that should be "sizeof(ms.fieldA)". Certainly you have noticed that.

[donbock]

It also works because you are working with char arrays; and sizeof(char) is 1 by definition.

For example, let's assume sizeof(short) is 2.

short array1[10];
short array2[sizeof(array1)];

This doesn't do what you want because sizeof(array1) = 10*2 = 20. A common idiom is more like this:

short array1[10];
short array2[sizeof(array1)/sizeof(array1[0])];

Notice that this idiom also works for char arrays.

Same comment as weaknessforcats offered: this silently gives the wrong answer if array1 is a pointer instead of an array.