Thread: Casting malloc?

malloc returns a void pointer...what this means is that the return points to something, but that something could be more or less anything......so what you are doing above is giving a hint to the compiler that the data returned from malloc should be treated as a pointer to a char (or an array of chars).......

in std C, there's no need to cast from malloc, but of you are compiling your code as C++, it will give an error without the cast being present.....this is due to C++ being more type sensitive (it has to be due to its ability to define custom types)

Originally posted by pnxi
By the way, can any body expain how to use realloc() function, and it is better to use a example.
Thanx for help!

Try a search

>Then you don't fully understand my point.
Allow me to take a stab at it. You are saying that the following code is wrong if I wanted to simulate an array of integers:

Code:

#include <stdlib.h>
/*
** my_header.h declares a to be a pointer to double
*/
#include "my_header.h"

int main ( void )
{
  a = malloc ( 24 * sizeof *a );

  return 0;
}

No warnings.

As it is the compiler implicitly converts the void pointer to a double pointer, the usage is correct, but not what you wanted. If, however, you had included a type cast to int * the compiler would likely give you a warning about incompatible types:

Code:

#include <stdlib.h>
/*
** my_header.h declares a to be a pointer to double
*/
#include "my_header.h"

int main ( void )
{
  a = (int *)malloc ( 24 * sizeof *a );

  return 0;
}

C:\C\C.c(9) : warning C4133: '=' : incompatible types - from 'int *' to 'double *'

This is a valid point, but so is the case for not using type casting. In the end, not using type casting is encouraged, but it is very largely a matter of style.

-Prelude

To make it simple to understand...

Think of a void pointer as a union that has reference to every single type of data you could ever possibly think of. Hehe.

Quzah.

Regarding the usage of malloc, I prefer:

TYPE *ptr;

ptr = malloc( sizeof( TYPE ) * NUMBER_TO_ALLOCATE );

There is no benefit I can see to ever casting, unless you are implicitly converting from one type to another. In malloc's case, there is no reason to ever cast that I can envision. The return type of malloc is to a continuous block of N bytes where N is:

sizeof( TYPE ) * NUMBER_TO_ALLOCATE

As such, it really doesn't matter what it's cast into, the cast is a moot point. Once a pointer is pointing at some block of memory, it could care less what type it was cast to when it was originally set to the address.

Setting a pointer to point to an address does not change its type. As such, there is nothing that casting pointers from one type to the next provides, other than preventing your compiler from yelling at you. Example:

char *c;
int *i;
float *f;

f = (float*) i = (int*) c;

This will (I believe, haven't bothered trying it) prevent your compiler from *****ing at you, but the end result is irrelevent.

In the end, they all point to the same spot in memory, and in the end, when you increment any of them, they only increment by N bytes, where N is the size of each variable.

So the end result is, it doesn't matter what you cast a pointer to, it will still be its own type, and nothing you can do will change that, unless you implicitly force cast it in incrementation:

((float*)c)++;

Quzah.

Originally posted by JoeSixpack
The cast (if used) is you telling the compiler that this is what you meant.

You're missing the point. The compiler doesn't CARE what you cast to. It has no effect. There is no point what so ever in casting malloc! It provides NOTHING to your code. It is worthless. It doesn't MATTER what you cast to, because you are casting a VOID POINTER. Void pointers, as far as your compiler is concerned, can go to ANYTHING, and there is absolutely no point what so ever in casting the return.

You're just asking your compiler to yell at you by possibly casting it to the wrong type. There is no benifit what so ever in casting a void pointer. Period. Ever. End of story.

Originally posted by JoeSixpack

No, it's not meant to. It's so the compiler can give an error/warning. If you assign a block of memory to a different type of pointer than you had intended it may not have the desired affect.

We're talking about void pointers. There is no reason to ever cast a void pointer. Your compiler will not complain about it, because it is impossible to cast a void pointer to the wrong type. Ever.

The only reason you could ever possible get this wrong is if you typed the single malloc line wrong:

char * c = malloc( sizeof(float) * 100 );

And even then, it still won't care. The only way it would care, would be if you cast it implicitly. Why on earth would you?

char * c = (float*) malloc( sizeof( float ) * 100 );

And that's absurd. Why on earth would you ever do that? There is no point in EVER casting void pointers. Period.

Originally posted by JoeSixpack

Exactly, but if you want a block of memory that can be manipulated in 1 byte regions, but allocate it to a pointer that increments/decrements in 4 byte regions then the pointer isn't going to care that you've made a mistake. However, casting the return value of malloc allows your compiler to provide a warning to this affect.

Yes, but how in the hell would this ever happen? You would have to be incredibly stupid and drunk to have this happen. In this case, casting is not going to save you. If you are stupid enough to malloc this incorrectly in the first place, then the chances are you're going to have screwed up your cast anyway, so there again is no benifit.

Your argument is absurd, as is your example. I cannot envision this ever possibly happening. By all means, feel free to cast, but there is absolutely no point in ever doing so. Your example is incredibly far fetched. You're basicly saying "Hey, forget that you just declared a variable, and pretend that you think it's some other type!"


Quzah.

int *i = malloc(1);

And like the other absurd example given for reasons to typecast, only a fool would do this. And, just like the other example, there is no point to type casting this mistake, because with or without the typecast, you still end up with incorrect code and the type cast has no effect what so ever. Neither one produces an error. Neither one produces a warning. Neither one will fix your broken code. Like I've said: There is no reason to ever cast malloc. The only remote examples provided are so absurd they'd never happen in real life, or if they did, they'd happen by a total novice coder who wouldn't benifit either way from the cast, or without it.

Quzah.

int* p;

p=(char*)malloc(100);

so what? Compiler says: failure!
But what is the benefit?

It's a false sense of security:
p=(int*)malloc(100);

The compiler don't say anything - but it's also wrong...
What does it help?

If you don't know which type p is, you are completly lost.

I don't want to discuss such things. Go and read K&R. Do they cast?? Or look for other gurus! They will tell you all the same.

The only reason why one casts a void* is to keep compability with C++, there is no other reason.

It's funny to read...

I think noone will change their minds, so why discussing?

I (and as I see some others) keep doing it like the gurus, and you JoeSixpack keep casting.

I have learned that it is possible to program in a different style as the gurus, but I got to know, that it is somehow easier when you do what the gurus tell you