[jakes9x]

Is it important to define destructor in your program Or is it called automatically when costructors are used and is it only called when constructors are used?

#include<iostream>
class sample
{
int a, b;
public:
sample()
{
a=1;
b=2;
cout<<"a = "<<a << " b = "<<b <<endl;
}

sample(int x)
{
a = x;
b = x+1;


}

sample(int x, int y)
{
a = x+y;
b = y+10;
}

~sample()
{
cout<<"Destructor "<<endl;
}

void disp()
{
cout<<"a = "<<a << " b = "<<b <<endl;
}

};

main()
{
sample P;
sample A(3);
A.disp();
sample B(5,5);
B.disp();
}

The output of program will be

a = 1 b = 2
a = 3 b = 4
a = 10 b = 15
Destructor
Destructor
Destructor

Why the output is not like this First constructor does its job then destructor runs, then second constructor does its job then again destructor runs and so on.
like this
a = 1 b = 2
Destructor
a = 3 b = 4
Destructor
a = 10 b = 15
Destructor

How does it actually work what is the order

MOD EDIT: Added code tags. When posting code...USE CODE TAGS!!!

This post has been edited by JackOfAllTrades: 09 December 2012 - 04:48 AM

[AKMafia001]

Destructor is executed when the class object is destroyed. When an object goes out of scope, or a dynamically allocated object is explicitly deleted using the delete keyword, the class destructor is called to help clean up the class before it is removed from memory. For simple classes the destructor is not needed, but if you want to do something important, like closing open files or some other task, you can do it in the destructor...

As for why the program executes the destructors in the end is because the objects you have created goes out of scope once the control reaches to end of main i.e. the right closing brace... So, the objects go out of scope and their destructors are called... If you want to see the destructor earlier, try to allocate an object with new and then delete it, you will see the destructor gets called earlier...

[Xupicor]

See scope of variables.

edit: And definitely see C++ FAQ Lite entries on destructors.

Play with the code below:

Spoiler

#include <iostream>
#include <string>

class A {
  static int last_id;
  public:
    const int id;
    const std::string name;

    A() : id(++last_id) {
      std::cout << "A(" << id << ")\n"; 
    }
    A(const std::string& name) : id(++last_id), name(name) {
      std::cout << "A(" << id << ", " << name << ")\n"; 
    }
    A(const A& copy) : id(++last_id), name("copy of " + copy.name) {
      // copy-constructor
      std::cout << "A(" << id << ", " << name << ") cctor\n"; 
    }

    ~A() {
      std::cout << "~A(" << id;
      if (!name.empty()) {
        std::cout << ", " << name;
      }
      std::cout << ")\n";
    }
};
int A::last_id = 0;

A global("global");
A second_global("second global");
A global_array[3];


void foo(const A& a) { // parameter is a reference
  A local("foo - local");
}

void bar(A a) { // parameter is a copy!
  A local("bar - local");
}

void baz(A a = A("default parameter")) {
  A local("baz - local");
}

A* allocate_A(const std::string& name) {
  return new A(name);
}

void delete_A(A*& ptr) {
  delete ptr;
  ptr = NULL;
}

int main() {
  A a1("first local");
  {
    A a("nested local");
  }
  A* ptr = allocate_A("allocated in function");
  
  for (A counter("for counter"); counter.id == -1;) {
    A a("in for loop"); // never reaches here
  }
  
  A array[2];
  A* dynamic_array = new A[3];
  
  while (A("while counter").id == -1) { // unnamed temp object A("while counter")
    A a("in while loop"); // never reaches here
  }
  
  delete[] dynamic_array;
  delete_A(ptr);

  for (int i = 0; i < 5; ++i) {
    A a("in for loop - local");
  }

  A* ptr2 = new A("ptr");
  A a2("second local");
  delete ptr2;
  
  foo(a1);
  foo(a2);
  
  bar(a1);
  bar(a2);

  baz(a2);
  baz();
  baz();

  std::cout << "-------------- end of main -------------\n";
  return 0;
}

This post has been edited by Xupicor: 09 December 2012 - 09:38 AM

[AKMafia001]

@Xupicor, Excellent example! I'm gonna save this code...

[vividexstance]

One thing to note is that you can arbitrarily create scopes. Sometimes people like to limit the life of a variable so they do something like:

int main()
{
    // ... do some work
    {
        // create some variables and do some work
    }
}

Any variables declared inside the nested curly braces will be constructed when the code reaches the opening curly-brace, and the destructors will be run at the end of the nested curly braces.

This post has been edited by vividexstance: 09 December 2012 - 09:12 AM

[Xupicor]

@OP, and my example

That goes without saying that if you want to know what happens you really should get some good source (recommended C++ books, ISO/IEC C++ standard if your stomach is up to it) and read about what is guaranteed and what is not.

TIAS (Try It And See) is great, but remember that with C and C++ just because code compiles and "works" doesn't mean it's valid. Also, just because your compiler does some things some way doesn't always mean that some other won't do it differently. There are things that are guaranteed by the language standard, but... Undefined behaviours are not as hard to invoke as you'd think, so beware.

TL;DR: If you find yourself guessing at something, then stop and check source material.

This post has been edited by Xupicor: 09 December 2012 - 09:21 AM