Correct usage of malloc()

How do you correctly use malloc()? I.E. without casts. I thought this was how:

Code:

---

int* data = malloc(sizeof(int) * 10);

---

But my compiler complains that it 'cannot convert void* to int*', so I'm forced to use a '(int*)' cast.

Oh yeah, and when do I use each of reinterpret_cast, static_cast and const_cast?

malloc returns void*, so you will have to cast. Since you posted this is the c++ forum and not the c forum, I am curious to why you aren't using new instead?

int* data = new int[10];

I was just wondering really. Is malloc() considered standard C++?

yes std::malloc() is a standard function. Its a holdover from C and is generally nowhere near as useful as the new operator but it does have its moments.

That's good to know. What about reinterpret_cast? Is it the same as a standard C cast?

Code:

---

int* data = (int*) malloc(10);
 
int* data = reinterpret_cast<int*> (malloc(10));

---

??

New calls constructors, malloc does not.

Code:

---

#include <iostream>
#include <cstdlib>

using namespace std;

class foo {
  int bar;
  public:
    foo();
};

foo::foo ( ) {
  cout << "Made a foo at address " << reinterpret_cast<void*>(this) << endl;
}

int main ( void ) {
  foo one;
  foo *bad = (foo*)malloc ( sizeof *bad );
  foo *good = new foo;
  cout << "One  is at address " << reinterpret_cast<void*>(&one) << endl;
  cout << "Bad  is at address " << reinterpret_cast<void*>(bad) << endl;
  cout << "Good is at address " << reinterpret_cast<void*>(good) << endl;
  return 0;
}

---

Quote:

---

Originally Posted by ahluka

That's good to know. What about reinterpret_cast? Is it the same as a standard C cast?

Code:

---

int* data = (int*) malloc(10);
 
int* data = reinterpret_cast<int*> (malloc(10));

---

??

---

static_cast is same as C cast
taken from MSDN:

Quote:

---

The reinterpret_cast operator allows any pointer to be converted into any other pointer type. It also allows any integral type to be converted into any pointer type and vice versa

The static_cast operator converts expression to the [casted type] based solely on the types present in the expression. No run-time type check is made to ensure the safety of the conversion.r

The const_cast operator can be used to remove the const, volatile, and __unaligned attribute(s) from a class.

[and for completeneess]

The expression dynamic_cast<type-id>( expression ) converts the operand expression to an object of type type-id. The type-id must be a pointer or a reference to a previously defined class type or a pointer to void.

---

There is a more detail explanation on each specific MSDN page and I'd encourage you to read them fully.

http://msdn.microsoft.com/library/de...express_71.asp

Thanks for all your replies :)

none of the casts are exactly the same as C style.
Each cast operator has its rules about what it can cast to what. reinterpret_cast is the one that is least portable. It is implementation defined how this one works. In general it is just a reinterpretation of the bits but this is not necessarily so.

Instead of malloc you can use the std::allocator to allocate memory without constructing.