What are “::operator new” and “::operator delete”?

Question

I know new and delete are keywords.

int obj = new int;
delete obj;

int* arr = new int[1024];
delete[] arr;

Answer 1

the new keyword (used alone) is not the same as the operator new function.

Calling

Object* p = new Object(value);

is equvalent in calling

void* v = operator new(sizeof(Object));
p = reinterpret_cast<Object*>(v);
p->Object::Object(value); //this is not legal C++, it just represent the implementation effect

The operator new (or better the void* operator new(size_t) variant) just allocate memory, but does not do any object construction.

The new keyword calls the operator new function, but then calls the object constructor.

To separate allocation from contruction, a variant of operator new is declared as

void* operator new(size_t, void* at)
{ return at; }

and the previous code is typically written as

Object* p = reinterpret_cast<Object*>(operator new(sizeof(Object))); //no contruction here
new(p) Object(value); //calls operator new(size_t, void*) via keyword

The operator new(size_t, void*) does nothing in itself, but, being invoked by the keyword will result in the contructor being called.

Reversely, destruction and deallocation can be separated with

p->~Object();
operator delete(p); //no destructor called

instead of delete p; that calls the destructor and then operator delete(void*).

Answer 2

:: tells the compiler to call the operators defined in global namespace.
It is the fully qualified name for the global new and delete operators.

Note that one can replace the global new and delete operators as well as overload class-specific new and delete operators. So there can be two versions of new and delete operators in an program. The fully qualified name with the scope resolution operator tells the compiler you are referring to the global version of the operators and not the class-specific ones.

Answer 3

:: means just a global namespace

Answer 4

They are allocator and deallocator functions. The new operator does two things: it calls an allocator function to get the memory, and it calls the constructor of the object. The delete operator also does two things: it calls the destructor, and then calls the a deallocator function. The default allocator function is ::operator new, and the default deallocator function is ::operator delete. Both can be replaced by the user.

Note that in a new expression, the ::operator new function is looked up in more or less the same manner as it would be if it were a normal function called from within a member function. As for normal functions, you can qualify the operator to change the lookup: new MyClass will find a member operator new if one is present; ::new MyClass will use the default allocator, even if MyClass defines a member operator new.