Why do we need to cast what malloc returns?

2020-02-06 03:17发布

    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

标签: c malloc heap
7条回答
走好不送
2楼-- · 2020-02-06 03:19

You tend to see this kind of C code from novices (or C++ coders :-) ):

int main() {
    int len = 40;
    char *my_string = (char *) malloc(sizeof(char)*len);
    return 0;
}

This is unnecessary and evil, you can avoid the useless cast via including stdlib.h

#include <stdlib.h>
int main() {
    int len = 40;
    char *my_string = malloc(sizeof(char)*len);
    return 0;
}
查看更多
Juvenile、少年°
3楼-- · 2020-02-06 03:23

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.

查看更多
Fickle 薄情
5楼-- · 2020-02-06 03:31

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 of malloc to the appropriate type. Usually, this isn't much of an issue, because C++ code tends to use new rather than malloc, which doesn't require typecasting.

查看更多
我欲成王,谁敢阻挡
6楼-- · 2020-02-06 03:38

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.

查看更多
beautiful°
7楼-- · 2020-02-06 03:43

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 using new.

查看更多
登录 后发表回答