I asked a question earlier on defining a structure using malloc. This was the answer I was given by the majority:
struct retValue* st = malloc(sizeof(*st));
I was showing a friend my code, and we came to a stumbling block.
Could someone please explain why this code works?
From my viewpoint, *st hasn't been defined when you malloc it, so there could be any kind of garbage in there. It should be malloc(sizeof(struct retValue))
Thanks for any help
The sizeof operator doesn't actually evaluate its operand - it just looks at its type. This is done at compile time rather than runtime. So it can safely be performed before the variable has been assigned.
Sizeof looks at the type of the expression given to it, it does not evaluate the expression. Thus, you only need to make sure that the variables used in the expression are declared so that the compiler can deduce their type.
In your example, st is already declared as pointer-to-struct-retValue. Consequently the compiler is able to deduce the type of the expression "*st".
Although it doesn't look like it is already declared in your code, the compiler has already taken care of it for you. All declarations in your code are moved to the beginning of the block in which they occur by the compiler. Suppose you write
One way to illustrate the knowledge that is available to the compiler is to look at the intermediate output it generates. Consider this example code...
struct retValue {long int a, long int b};
...
printf("Hello World!\n");
struct retValue* st = malloc(sizeof(*st));
Using gcc as an example and teh above code in the main() function of test.c, let's look at the intermediate output by running...
gcc -fdump-tree-cfg test.c
The compiler will generate the file test.c.022t.cfg - Look at it and you'll see
[ ... removed internal stuff ...]
;; Function main (main)
Merging blocks 2 and 3
main (argc, argv)
{
struct retValue * st;
int D.3097;
void * D.3096;
# BLOCK 2
# PRED: ENTRY (fallthru)
__builtin_puts (&"Hello World!"[0]);
D.3096 = malloc (16);
st = (struct retValue *) D.3096;
D.3097 = 0;
return D.3097;
# SUCC: EXIT
}
Note how the declaration was moved to the beginning of the block and the argument to malloc is already replaced with the actual value denoting the size of the type the expression evaluated to. As pointed out in the comments, the fact that the declaration was moved to the top of the block is an implementation detail of the compiler. However, the fact that the compiler is able to do this and also to insert the correct size into the malloc all shows that the compiler was able to deduce the necessary information from the input.
I personally prefer to give the actual type name as a parameter to sizeof, but that is probably a question of coding-style where I'd say that consistency trumps personal-preference.
What matters is the declaration/definition of the structure type and not the definition of an object of such a class. By the time you reach the malloc, a declaration/definition will have been encountered by the compiler, you'd hit a compiler error otherwise.
The fact that sizeof does not evaluate its operands is a side-issue.
A minor nit: remember that we need parentheses when we supply type names to sizeof as in:
sizeof(struct retValue);
and not in case of objects, we simply do:
sizeof *st;
See the standard:
6.5.3 Unary operators Syntax
unary-expression:
[...]
sizeof unary-expression
sizeof ( type-name )
In C, sizeof is an operator, and doesn't evaluate its argument. That can lead to "interesting" effects, that someone new to C does not necessarily anticipate. I mentioned that in more detail in my answer to the "Strangest language feature" question.
