What is the difference between new/delete and malloc/free?

What is the difference between new/delete and malloc/free?

Related (duplicate?): In what cases do I use malloc vs new?

new / delete

• Allocate / release memory
  1. Memory allocated from 'Free Store'.
  2. Returns a fully typed pointer.
  3. new (standard version) never returns a NULL (will throw on failure).
  4. Are called with Type-ID (compiler calculates the size).
  5. Has a version explicitly to handle arrays.
  6. Reallocating (to get more space) not handled intuitively (because of copy constructor).
  7. Whether they call malloc / free is implementation defined.
  8. Can add a new memory allocator to deal with low memory (std::set_new_handler).
  9. operator new / operator delete can be overridden legally.
  10. Constructor / destructor used to initialize / destroy the object.

malloc / free

• Allocate / release memory
  1. Memory allocated from 'Heap'.
  2. Returns a void*.
  3. Returns NULL on failure.
  4. Must specify the size required in bytes.
  5. Allocating array requires manual calculation of space.
  6. Reallocating larger chunk of memory simple (no copy constructor to worry about).
  7. They will NOT call new / delete.
  8. No way to splice user code into the allocation sequence to help with low memory.
  9. malloc / free can NOT be overridden legally.

Table comparison of the features:

Feature	new / delete	malloc / free
Memory allocated from	'Free Store'	'Heap'
Returns	Fully typed pointer	void*
On failure	Throws (never returns NULL)	Returns NULL
Required size	Calculated by compiler	Must be specified in bytes
Handling arrays	Has an explicit version	Requires manual calculations
Reallocating	Not handled intuitively	Simple (no copy constructor)
Call of reverse	Implementation defined	No
Low memory cases	Can add a new memory allocator	Not handled by user code
Overridable	Yes	No
Use of constructor / destructor	Yes	No

Technically, memory allocated by new comes from the 'Free Store' while memory allocated by malloc comes from the 'Heap'. Whether these two areas are the same is an implementation detail, which is another reason that malloc and new cannot be mixed.

The most relevant difference is that the new operator allocates memory then calls the constructor, and delete calls the destructor then deallocates the memory.

new calls the ctor of the object, delete call the dtor.

malloc & free just allocate and release raw memory.

new/delete is C++, malloc/free comes from good old C.

In C++, new calls an objects constructor and delete calls the destructor.

malloc and free, coming from the dark ages before OO, only allocate and free the memory, without executing any code of the object.

In C++ new/delete call the Constructor/Destructor accordingly.

malloc/free simply allocate memory from the heap. new/delete allocate memory as well.

The main difference between new and malloc is that new invokes the object's constructor and the corresponding call to delete invokes the object's destructor.

There are other differences:

• new is type-safe, malloc returns objects of type void*

• new throws an exception on error, malloc returns NULL and sets errno

• new is an operator and can be overloaded, malloc is a function and cannot be overloaded

• new[], which allocates arrays, is more intuitive and type-safe than malloc

• malloc-derived allocations can be resized via realloc, new-derived allocations cannot be resized

• malloc can allocate an N-byte chunk of memory, new must be asked to allocate an array of, say, char types

Looking at the differences, a summary is malloc is C-esque, new is C++-esque. Use the one that feels right for your code base.

Although it is legal for new and malloc to be implemented using different memory allocation algorithms, on most systems new is internally implemented using malloc, yielding no system-level difference.

The only similarities are that malloc/new both return a pointer which addresses some memory on the heap, and they both guarantee that once such a block of memory has been returned, it won't be returned again unless you free/delete it first. That is, they both "allocate" memory.

However, new/delete perform arbitrary other work in addition, via constructors, destructors and operator overloading. malloc/free only ever allocate and free memory.

In fact, new is sufficiently customisable that it doesn't necessarily return memory from the heap, or even allocate memory at all. However the default new does.

There are a few things which new does that malloc doesn’t:

1. new constructs the object by calling the constructor of that object
2. new doesn’t require typecasting of allocated memory.
3. It doesn’t require an amount of memory to be allocated, rather it requires a number of objects to be constructed.

So, if you use malloc, then you need to do above things explicitly, which is not always practical. Additionally, new can be overloaded but malloc can’t be.

In a word, if you use C++, try to use new as much as possible.

also,

the global new and delete can be overridden, malloc/free cannot.

further more new and delete can be overridden per type.

new and delete are C++ primitives which declare a new instance of a class or delete it (thus invoking the destructor of the class for the instance).

malloc and free are C functions and they allocate and free memory blocks (in size).

Both use the heap to make the allocation. malloc and free are nonetheless more "low level" as they just reserve a chunk of memory space which will probably be associated with a pointer. No structures are created around that memory (unless you consider a C array to be a structure).

new and delete are operators in c++; which can be overloaded too. malloc and free are function in c;

malloc returns null ptr when fails while new throws exception.

address returned by malloc need to by type casted again as it returns the (void*)malloc(size) New return the typed pointer.

• new is an operator, whereas malloc() is a fucntion.
• new returns exact data type, while malloc() returns void * (pointer of type void).
• malloc(), memory is not initialized and default value is garbage, whereas in case of new, memory is initialized with default value, like with 'zero (0)' in case on int.
• delete and free() both can be used for 'NULL' pointers.

• To use the malloc(), we need to include <stdlib.h> or <alloc.h> in the program which is not required for new.
• new and delete can be overloaded but malloc can not.
• Using the placement new, we can pass the address where we want to allocate memory but this is not possible in case of malloc.

This code for use of delete keyword or free function. But when create a pointer object using 'malloc' or 'new' and deallocate object memory using delete even that object pointer can be call function in the class. After that use free instead of delete then also it works after free statement , but when use both then only pointer object can't call to function in class.. the code is as follows :

#include<iostream>


using namespace std;

class ABC{
public: ABC(){
  	cout<<"Hello"<<endl;
  }
  
  void disp(){
  	cout<<"Hi\n";
  }
  
};

int main(){

ABC* b=(ABC*)malloc(sizeof(ABC));
int* q = new int[20];
ABC *a=new ABC();
b->disp();

cout<<b<<endl;
free(b);
delete b;
//a=NULL;
b->disp();
ABC();
cout<<b;
return 0;
}

> output : >
> Hello > Hi > 0x2abfef37cc20

1.new syntex is simpler than malloc()

2.new/delete is a operator where malloc()/free() is a function.

3.new/delete execute faster than malloc()/free() because new assemly code directly pasted by the compiler.

4.we can change new/delete meaning in program with the help of operator overlading.