Destructors called without matching constructor

Question

I am trying to figure out how C++ resource management works, especially in relation to constructors/destructors. This is my test code;

ylist.h

#pragma once
template <class T>
struct ListNode
{
    T elem;
    struct ListNode* next;
    ListNode(T elem):elem(elem),next(nullptr) {}
};

template <class T>
class List
{
    ListNode<T> *head;

public:
    List() : head(nullptr)
    {

    }
    ~List()
    {
        ListNode<T>* cursor = head;
        while (cursor != nullptr)
        {
            ListNode<T>* next = cursor->next;
            delete cursor;
            cursor = next;
        }
    }
    void append(T item)
    {
        ListNode<T>* n = new ListNode<T>(item);
        if (head == nullptr)
        {
            head = n;
        }
        else
        {
            ListNode<T>* cursor = head;
            while (cursor->next != nullptr)
                cursor = cursor->next;
            cursor->next = n;
        }
    }
};

main.cpp

#include <iostream>
#include "ylist.h"

using namespace std;

class myObj
{
    int val;
public:
    myObj(int val):val(val)
    {
        cout << "myObj@" << this << "(" << val << ")" << endl;
    }

    ~myObj()
    {
        cout << "~myObj@" << this << "(" << val << ")" << endl;
    }

};

int main()
{
    List<myObj> myList;

    for (int i = 0; i < 3; i++)
    {
        myList.append(myObj(i));
    } 
}

And here is the output;

myObj@00000039614FFAC0(0)
~myObj@00000039614FFAD0(0)
~myObj@00000039614FFAC8(0)
~myObj@00000039614FFAC0(0)
myObj@00000039614FFAC0(1)
~myObj@00000039614FFAD0(1)
~myObj@00000039614FFAC8(1)
~myObj@00000039614FFAC0(1)
myObj@00000039614FFAC0(2)
~myObj@00000039614FFAD0(2)
~myObj@00000039614FFAC8(2)
~myObj@00000039614FFAC0(2)
~myObj@0000019878DF6100(0)
~myObj@0000019878DF5F20(1)
~myObj@0000019878DF6200(2)

According to above output, constructor called for each object once, but destructors called four times.

I was expecting to see multiple temporary copies being constructed/destructed but why is number of constructors/destructos is not matching.

If, for example, I was opening files or db connections on constructors and closing them on destructors, would I get in trouble in above scenario?

You need to instrument the copy constructor as well. `void append(T item)` takes a `myObj` by value ie copies it. `ListNode(T elem)` also takes a `myObj` by value and makes another copy. And finally copies it again here `: elem(elem)` — Richard Critten, Jan 14 '23 at 19:32
`void append(T item)` takes by value, therefore calls implicitly defined (default) copy/move constructors. Those will also get destroyed, causing the output you see — UnholySheep, Jan 14 '23 at 19:32
Related: [What is The Rule of Three?](https://stackoverflow.com/questions/4172722/) — JaMiT, Jan 15 '23 at 07:48

score 2 · Accepted Answer · answered Jan 14 '23 at 19:35

Add this copy constructor to your myObj function in order to see how the additional myObj objects are being constructed. Once you have this, you'll see that the number of constructor-calls matches the number of destructor-calls.

myObj(const myObj & rhs):val(rhs.val)
{
    cout << "COPY CTOR myObj@" << this << "(" << val << ")" << endl;
}

Destructors called without matching constructor

1 Answers1