int length = strlen(src);
char *structSpace = malloc(sizeof(String) + length + 1);
String *string = (String*) structSpace;
int *string = (int*) structSpace;
*I created a struct called String
int length = strlen(src);
char *structSpace = malloc(sizeof(String) + length + 1);
String *string = (String*) structSpace;
int *string = (int*) structSpace;
*I created a struct called String
You tend to see this kind of C code from novices (or C++ coders :-) ):
This is unnecessary and evil, you can avoid the useless cast via including
stdlib.h
Because malloc returns a pointer to void, i.e., it is simply allocating chunks of memory with no regard as to the data that will be stored there. In C++ your returned void* will not be implicitly cast to the pointer of your type. In your example, you have not cast what malloc has returned. Malloc returned a void* which was implicitly cast to a char*, but on the next line you... ok, it doesn't make much sense anymore.
The C FAQ list is an invaluable resource: Why does some code carefully cast the values returned by malloc to the pointer type being allocated?.
This is one of the few issues that makes the statement "C++ is a superset of C" not completely true. In C, a
void
pointer can be implicitly cast to any other type of pointer. However, C++ is a bit more strict with type safety, so you need to explicitly cast the return value ofmalloc
to the appropriate type. Usually, this isn't much of an issue, because C++ code tends to usenew
rather thanmalloc
, which doesn't require typecasting.You don't.
void*
will implicitly cast to whatever you need in C. See also the C FAQ on why you would want to explicitly avoid casting malloc's return in C. @Sinan's answer further illustrates why this has been followed inconsistently.In C, casting the result from malloc is unnecessary and should not be done. Doing so can, for example, cover up the error of having failed to
#include <stdlib.h>
, so you don't have a prototype for malloc in scope. This, in turn, can lead to other errors and lack of portability (though the worst offenders in that respect are now mostly obsolete).In C++, you must cast the result of malloc to assign it to a pointer to any type other than void. Unless you really need to write code that can be compiled as either C or C++, however, you should generally avoid using
malloc
in C++ at all and allocate memory usingnew
.