When does a destructor of a class is called ?

Question

I have a list class which holds a pHead pointer and a typical print function. I use another function (not in the list class) that takes the above list as its argument(non-ref type) and calls its print function.When i call this "another function" to print the the list, it also call the destructor of the list after printing. Is it supposed to be like that ? Can someone explain that to me?
P.s: sorry for the bad english :P

Answer 1

A destructor function is called automatically when the object goes out of scope:

1. the function ends
2. the program ends
3. a block containing local variables ends
4. a delete operator is called

In your case, the destructor is called because when you pass the object of your list class, it creates a copy of that object in the function, and when the function ends this newly created object goes out of scope and hence the destructor is called.

---

Edit : Expanding onto the answer ; There are three main types of memory

1. automatic storage (stack)
2. dynamic storage (heap)

3. static storage

   1. If you allocate an object in automatic storage the the object will be destroyed once the scope is terminated; for example

void foo() {
MyClass myclass_instance;
myclass_instance.doSomething();
}

in the above case when the function terminates myclass_instance is destroyed automatically.

2. Objects reside in dynamic memory (the heap). They are allocated with new and in order for the dstructor to be called, you need to call delete:

   int main()
   {
     A* a = new A;
     delete a;    //destructor called
   }
   

3. Static allocation : Objects reside in static memory. Regardless of where they are allocated, the destructor is automatically called when the program ends:

   A a; //namespace scope
   
   int main()
   {
   }
   

Here, As destructor is called when the program terminates, after main finishes.

Answer 2

The destructor is called for an object if it reaches the end of its life span, i.e.

1. When the control reaches the end of its scope (closing curly braces) (for objects with automatic storage duration)
2. When you call delete (or delete[]) for objects allocated with new (or new[]) (for objects with dynamic storage duration)
3. When its parent is destroyed (for class member object)
4. When you manually delete an object created with an overloaded new operator
5. When the program exits (for objects with static storage duration)

According to your explanation, I guess that you're passing it by value. When the function reaches its end, the copy of the object also reaches the end of its life span, so its destructor is called automatically.

For example (Case x means object tx is destroyed here):

struct T{
    int a;
    ~T() { /* anything */ }
} t5;
struct U{
    T t3;
};

void foo() {
    T t1;
}  // Case 1

int main() {
    foo();
    // Case 1

    T *pt2 = new T();
    delete pt2;  // Case 2

    {
        U u1;
    }  // Case 3

    void *buf = malloc(1000);
    T *pt4 = new(buf) T();
    pt4 -> ~T(); // Case 4

    return 0; // Case 5
}