Thread: quick malloc/pointer Q

malloc returns a pointer to a chunk of memory of the requested size. Hence, you must declare a pointer like:

my_struct *m;

and use it to hold the return value. Also, malloc returns a (void *), that is, pointer to void, and you must cast it into the required type before using:

my_struct *m = (my_struct *)malloc(sizeof(my_struct));

Originally posted by vikasgp
Also, malloc returns a (void *), that is, pointer to void, and you must cast it into the required type before using:

In C++,Yes,In C no.
Sometimes it can be dangerous to cast the return value.
From comp.lang.c

Standard C does not require a cast for assignments from a (void *) type to
some other pointer type. The "narrowing" is done for you. Since malloc()
returns a `void *', no cast is required.

As has been repeated here before, an explicit cast is discouraged,
because if there is not a prototype in scope, malloc() is assumed to be
a function returning an `int'. Without a prototype in scope, the cast
will hide the fact that malloc() has returned an `int' rather than a
`void *', and your compiler will not have had the opportunity to warn
you about the mistake. If the size of an `int' is not the same size as
a `void *' on your machine, then `bad things will happen'. If it does
happen to work on your machine, then you will become terribly confused
when the identical code does not work on someone else's machine.
....
If you get a warning about there being no prototype for malloc() in
scope then your code is broken, pure and simple. No amount of casting
will cure it.

This is the reason for advising against casting the result of malloc().
If you cast the result of malloc then *some* compilers will still detect
the error of not including stdlib.h. If you don't cast the result
of malloc then *all* compilers will detect it.

See,you must allocate memory for your struct,and thats sizeof(*myData),or sizeof(MY_DATA).
The other one only allocates memory for a pointer to a MY_DATA struct
Ex.

Code:

struct Foo
{
    int array[10];
};
...
struct Foo* pFoo;
sizeof(*pFoo); /* around 40 */
sizeof(pFoo); /* around 4 */
/*Size depends on your compiler */

In C++,Yes,In C no.
Sometimes it can be dangerous to cast the return value.

Thanks for pointing that out. However...
From the libc info:

You can store the result of `malloc' into any pointer variable
without a cast, because ISO C automatically converts the type `void *'
to another type of pointer when necessary. But the cast is necessary
in contexts other than assignment operators or if you might want your
code to run in traditional C.

Also, in all the code I've seen, the result is casted.