What is the mechanism through which destructors are called for stack-assigned objects?

Question

How does C++ ensure that destructors are called for stack assigned objects? What happens to the destructor function (or a pointer to it) when I assign dynamic memory as follows:

class MyClass {
public:

  ~MyClass()
  {
    std::cout<<"Destructor called."<<std::endl;
  }  

  MyClass()
  {
    std::cout<<"Constructor called."<<std::endl;
  }

};

....................................................................

//Limit scope for example
{
  MyClass instance;
}

The constructor and destructor are both called. What's going on here?

Answer 1

The constructor is called because you're creating an object. The destructor is called because your cleaning up that object. Remember, in C++, objects declared on the stack are automatically cleaned up when their containing scope goes away.

Answer 2

The constructor is called as soon as the variable is created. As for the destructor, the compiler emits code at the end of scope to call the destructor. To get a feel for this, try using a 'goto', or switch/case construct to prematurely exit the scope, and watch the compiler complain.

Answer 3

The compiler inserts a call to the destructor for the object at an appropriate position.

Answer 4

Yes, both the constructor and destructor are called. And even more important:

{
 MyClass instance;
 throw "exception";
}

in this example, the destructor is also called. That is why I always prefer to allocate my objects on stack (or at least wrap the dynamic allocations with a stack-allocated guardians).

Answer 5

You wouldn't wonder why this

{
  int i;
}

creates and destroys i automatically, would you? C++ does a lot to allow you to create types that behave just like built-in types. And just like with built-in types, in C++ (other than in, say, Java or C#), this

{
  MyClass instance;
}

doesn't just define a reference that might be bound to null or some actual object. It creates an actual object.

Object creation comes in two steps: First (upon entering the scope) the raw memory is provided. Then (when the object definition is encountered) the constructor is called. For built-in types no constructor is called. If you don't initialize a built-in variable, it has a random value. (Actually it's whatever the bit pattern was at the memory provided in step #1.) Object deletion, too, comes in two steps: First, the destructor is called (again, not for built-ins), then the memory is returned to the run-time system.

(Note that providing and deleting memory for stack variables usually is as cheap as incementing/decrementing a register.)

Answer 6

well it did not call the destructor just after constructor.

it calls it when it about to terminate the programme.

int main() { MyClass obj;

cout<<"testing....1"<<endl;

cout<<"testing....2"<<endl;
return 0;

}

ans: Constructor called. testing....1 testing....2 Destructor called.