I saw code like this:
void *NewElts = operator new(NewCapacityInBytes); And matching call explicitly operator delete is used consequent later.
Why do this instead of:
void *NewElts = new char[NewCapacityInBytes]; Why explicit call to operator new and operator delete??
Explicitly calling operator new like that calls the global "raw" operator new. Global operator new returns a raw memory block without calling the object's constructor or any user-defined overloads of new. So basically, global operator new is similar to malloc from C.
So:
// Allocates space for a T, and calls T's constructor, // or calls a user-defined overload of new. // T* v = new T; // Allocates space for N instances of T, and calls T's // constructor on each, or calls a user-defined overload // of new[] // T* v = new T[N]; // Simply returns a raw byte array of `sizeof(T)` bytes. // No constructor is invoked. // void* v = ::operator new(sizeof(T)); 
new. Depending on the allocation pattern, this can provide better performance than new and delete.
operator new does, but it doesn't explain why we'd use operator new(N) instead of new char[N]. That was the question, after all.
new T[N].If you write:
T *p = new T; That allocates enough memory to hold a T, then constructs the T into it. If you write:
T *p = ::operator new(sizeof(T)); That allocates enough memory to hold a T, but doesn't construct the T. One of the times you might see this is when people are also using placement new:
T *p = ::operator new(sizeof(T)); // allocate memory for a T new (p) T; // construct a T into the allocated memory p->~T(); // destroy the T again ::operator delete(p); // deallocate the memory If you call operator new(bytesize), then you can delete it using delete, whereas if you allocate via new char[bytesize], then you have to match it using delete[], which is an abomination to be avoided wherever possible. This is most likely the root reason to use it.
operator new you can deallocate it using global operator delete. But global operator delete won't call the destructor. So if you actually construct an object using placement new after calling global operator new, then global operator delete alone is not sufficient to destroy the object. You need to also invoke the destructor explicitly before deallocating the memory. Essentially, both global operator new and operator delete allow you to decouple storage allocation/deallocation and object initialization/destruction.
Use it when you want to allocate a block of "raw" memory and don't want anything constructed in that memory.
There is little practical difference between allocating a block of raw memory and "constructing" an array of chars but using operator new clearly signals your intent to anyone reading the code which is important.
