tags:

views:

93

answers:

3

I know that, new operator will call the constructor of class.

But how it's happening, what is ground level techniques used for this.

+1  A: 

The compiler generates machine code for that. When the compiler sees

CSomeClass* object = new CSomeClass();

(new statement) it generates code that calls the appropriate operator new() (which allocates memory), calls the right constructor, calls destructors of all fully constructed subobjects in case of exception, calls operator delete() in case an exception occurs during construction. All this is done by extra machine code generated by the C++ compiler for that simply looking statement.

sharptooth
+3  A: 

Here is how I imagine it:

T* the_new_operator(args)
{
    void* memory = operator new(sizeof(T));
    T* object;
    try
    {
        object = new(memory) T(args);   // (*)
    }
    catch (...)
    {
        operator delete(memory);
        throw;
    }
    return object;
}

(*) Technically, it's not really calling placement-new, but as long as you don't overload that, the mental model works fine :)

FredOverflow
@FredOverflow: This is very simplified and doesn't reflect the fact that when an exception is thrown all *completely constructed* subobjects are run destructors on. Although I can't imagine how you could illustrate that in the preudocode.
sharptooth
@sharp But that's what any constructor always does, regardless of where the memory comes from. It is nothing that the new operator has to do specifically.
FredOverflow
+1  A: 

It's not really the new operator that calls the constructor. It is more the compiler that translate the following line:

MyClass * mine = new MyClass();

Into the following:

MyClass * mine = malloc(sizeof(MyClass));  // Allocates memory
mine->MyClass();                           // Calls constructor

With other error handling code that other answers have noted.

Didier Trosset
No, not ever `malloc()` - `operator new()` is what is called. Big difference (for example, you can overload `operator new()` per class).
sharptooth
True, but I used `malloc()` for the simplicity, and to try to indicate that it is only a matter of allocating a bunch of memory. Nothing else. Overloading `operator new` is more advanced considerations I woudn't use in an explanation for lower level questions as the current.
Didier Trosset
Sadly, the name `malloc` fits the purpose a lot better than `operator new`, because the latter is often confused with the new operator... :(
FredOverflow