Incomprehensible syntax in c/c++!! why can we malloc a buffer like this?

Question

Today,I noticed a bunch of code that Instantiate a struct like below while ServiceMsg is a struct.

ServiceMsg *msg = (ServiceMsg *)malloc(sizeof * msg);

I have never seen malloc can be used like this. Can anyone explain this to me??? size of buffer is often assigned like this malloc(sizeof(int) * n) as is known to me..

Answer 1

In the snippet,

  ServiceMsg *msg = (ServiceMsg *)malloc(sizeof * msg);

is the same as

 ServiceMsg *msg = (ServiceMsg *)malloc( 1* sizeof(*msg));

which is better written as

 ServiceMsg *msg = malloc(sizeof(*msg));

To elaborate, malloc() expects a size as the argument, and in this call, the size we are passing is sizeof(*msg), i.e., sizeof (ServiceMsg ).

That said, please see this discussion on why not to cast the return value of malloc() and family in C..

Answer 2

There's a few details that might make it confusing:

• The sizeof operator can be used in two ways: either with parenthesis sizeof(type), but then the argument must be a type like int. Or without parenthesis sizeof expr, then the argument can be an expression. But of course an expression can contain a parenthesis in itself...

• In your case sizeof *msg takes the size of the expression *msg, which means de-reference the pointer msg (it's not the multiplication operator!) so we end up with a "lvalue" temporary variable of type ServiceMsg. Which has the size of a ServiceMsg.

• Normally, de-referencing a pointer variable at the same line it is declared would be a big no-no, it is not initialized and is not yet pointing at any sensible location. The catch is that the sizeof operator does not actually evaluate (execute) its operand, so the expression *msg is never executed and de-referencing never happens.

This is why the code works. This style is often even recommended, since you don't have to worry about what type the pointer is pointing at - it's always type* ptr = malloc(sizeof *ptr); regardless of what you are allocating.

The cast to (ServiceMsg*) in your code is superfluous.

Answer 3

It would be more clear if to rewrite this call where the expression looks like a multiplication expression

malloc(sizeof * msg);

like

malloc(sizeof *msg);

The sizeof operator is defined the following way

sizeof unary-expression
sizeof ( type-name )

The expression *msg that is dereferencing the pointer msg is an unary expression. The type of the expression is determined (in this case it is ServiceMsg) and the size of an object of this type is calculated. The expression itself is not evaluated. The compiler only determines its type.

You could this unary expression enclose in parentheses getting a primary expression like

malloc(sizeof ( *msg ) );

In this this record looks similarly like this record

malloc(sizeof ( ServiceMsg ) );

Answer 4

Cleaning that up a little bit, we get

ServiceMsg *msg = malloc(sizeof *msg);

which is exactly the same as

ServiceMsg *msg = malloc(N * sizeof *msg);

where N == 1. This is a fairly common idiom in C for dynamically allocating memory:

T *p = malloc( N * sizeof *p ); // for any non-function type T

or

T *p;
...
p = malloc( N * sizeof *p );

or

T *p = calloc( N, sizeof *p );

or

T *p;
...
p = calloc( N, sizeof *p );

It has the advantage of not repeating type information, so maintenance is easier.

The cast is unnecessary¹, and since the type of the expression *msg is ServiceMessage, sizeof *msg == sizeof( ServiceMessage ).

Remember that sizeof is an operator, not a function - parentheses are only required if the operand is a type name like ServiceMessage or int or char, or if it's an arithmetic expression like 1 + 2. Since sizeof is a unary operator it has higher precedence than an arithmetic operator, so sizeof 1 + 2 is parsed as (sizeof 1) + 2, which probably isn't what you want.

---

1. Unless you're compiling this code as C++ or using an ancient K&R implementation. Prior to C89, the *alloc functions returned char * instead of void *, so a cast was necessary if the target wasn't a char *. C++ does not allow implicit conversion from void * to other pointer types, so it requires a cast as well, but if you're writing C++, you shouldn't be using C-style memory management anyway.