In what cases do I use malloc vs new?

Question

I am new to C++ programming but have a solid background in C#, Java and PHP. I see in C++ there are multiple ways to allocate and free data and I understand that when you call malloc you should call free and when you use the new operator you should pair with delete and it is a mistake to mix the two (eg. calling free() on something that was created with the new operator), but I'm not clear on when I should use malloc/free and when I should use new/delete in my real world programs.

If anyone is a C++ expert, please let me know any rules of thumb or conventions you follow in this regard.

Answer 1

Unless you are forced to use C, you should never use malloc. Always use new. If you need a big chunk of data just do something like:

char *pBuffer = new char[1024];

Be careful though this is not correct:

//This is incorrect - may delete only one element, may corrupt the heap, or worse...
delete pBuffer;

Instead you should do this when deleting an array of data:

//This deletes all items in the array
delete[] pBuffer;

The new keyword is the C++ way of doing it, and it will ensure that your type will have their constructor called. The new keyword is also more type safe whereas malloc is not typesafe at all.

The only way I could think that would be beneficial to use malloc would be if you needed to change the size of your buffer of data. The new keyword does not have an analogous way like realloc. The realloc function might be able to extend the size of a chunk of memory for you more efficiently.

It is worth mentioning that you cannot mix new/free and malloc/delete.

Note, some answers in this question are invalid.

int* p_scalar = new int(5);//Does not create 5 elements, but initializes to 5
int* p_array = new int[5];//Creates 5 elements

Answer 2

Use malloc and free only for allocating memory that is going to be managed by c-centric libraries and APIs. Use new and delete (and the [] variants) for everything that you control.

Answer 3

If you have C code you want to port over to C++, you might leave any malloc() calls in it. For any new C++ code, I'd recommend using new instead.

Answer 4

I'd just like to add a reminder that you cannot mix the two styles - that is, you cannot use new to create an object and then call free() on it, nor attempt to delete a block allocated by malloc().

Probably obvious to say it, but nonetheless...

Answer 5

Always use new in C++. If you need a block of untyped memory, you can use operator new directly:

void *p = operator new(size);
   ...
operator delete(p);

Answer 6

Good answers, all I have to add (that I haven't seen) is that new/delete calls the constructor/destructor for you, malloc/free does not.

Just a difference worth mentioning.

Answer 7

The original poster (or an editor) keeps removing my comment.

This was marked as offensive because the title and question were edited to this:

http://img371.imageshack.us/my.php?image=sofk9.jpg

Considering the profile of the original poster, I suspect he is the guilty person.

Answer 8

Reason for downvotes and offensive reports: Twice he edited his post to delete all text and replaced it with cuss words. Then minutes later he rolled it back to the original question.

Also, some people left comments explaining their downvotes, but they have been mysteriously deleted.

Answer 9

From the C++ FQA Lite:

[16.4] Why should I use new instead of trustworthy old malloc()?

FAQ: new/delete call the constructor/destructor; new is type safe, malloc is not; new can be overridden by a class.

FQA: The virtues of new mentioned by the FAQ are not virtues, because constructors, destructors, and operator overloading are garbage (see what happens when you have no garbage collection?), and the type safety issue is really tiny here (normally you have to cast the void* returned by malloc to the right pointer type to assign it to a typed pointer variable, which may be annoying, but far from "unsafe").

Oh, and using trustworthy old malloc makes it possible to use the equally trustworthy & old realloc. Too bad we don't have a shiny new operator renew or something.

Still, new is not bad enough to justify a deviation from the common style used throughout a language, even when the language is C++. In particular, classes with non-trivial constructors will misbehave in fatal ways if you simply malloc the objects. So why not use new throughout the code? People rarely overload operator new, so it probably won't get in your way too much. And if they do overload new, you can always ask them to stop.

Sorry, I just couldn't resist. :)

Answer 10

The new and delete operators can operate on classes and structures, wheres malloc and free only work with blocks of memory that need to be cast.

Using new/delete will help to improve your code as you will not need to cast allocated memory to the required data structure.