C++! How are destructors called - c++

Question

so i'm new to C++ (with java as a background) and i was going through copy constructor and destructor section but i still don't get it. The example i will show you is taken from tutorialpoints.com. So i have this code but the output just confuses me.
#include <iostream>
using namespace std;
class Line
{
public:
int getLength( void );
Line( int len ); // simple constructor
Line( const Line &obj); // copy constructor
~Line(); // destructor
private:
int *ptr;
};
// Member functions definitions including constructor
Line::Line(int len)
{
cout << "Normal constructor allocating ptr" << endl;
// allocate memory for the pointer;
ptr = new int;
*ptr = len;
}
Line::Line(const Line &obj)
{
cout << "Copy constructor allocating ptr." << endl;
ptr = new int;
*ptr = *obj.ptr; // copy the value
}
Line::~Line(void)
{
cout << "Freeing memory!" << endl;
delete ptr;
}
int Line::getLength( void )
{
return *ptr;
}
void display(Line obj)
{
cout << "Length of line : " << obj.getLength() <<endl;
}
// Main function for the program
int main( )
{
Line line1(10); //Line 1***************************
Line line2 = line1; // This also calls copy constructor
display(line1);
display(line2);
return 0;
}
Output
Normal constructor allocating ptr
Copy constructor allocating ptr.
Copy constructor allocating ptr.
Length of line : 10
Freeing memory!
Copy constructor allocating ptr.
Length of line : 10
Freeing memory!
Freeing memory!
Freeing memory!
So in line 1 (Main), why does it also call the copy constructor when it has its own argument?
Also after the first call to the method display why is there another call to the copy constructor ?
this is the input i would have expected
`Normal constructor allocating ptr //Because Line one has its argument
Copy constructor allocating ptr. //Because Line2 is a copy of Line1
Length of line : 10
Freeing memory! // Call to destructor after Line1 is desplayed
// Memory leak Since Line2 is now pointing to nothing, i guess is what we call `shallow pointers?!`
Sorry if it was too long, hopefully i was clear. PS i'm Only familiar with regular pointers!

Answer 1

What's confusing you is that display takes a Line by value. When you pass a Line to the display function, it copies it (calls copy ctor) into its local argument and when the display function ends, that local argument goes out of scope and the copied Line destructs.
int main( )
{
Line line1(10); // calls ctor that takes an int
Line line2 = line1; // calls copy ctor
display(line1); // calls copy ctor, prints, and then destructs the copy
display(line2); // calls copy ctor, prints, and then destructs the copy
return 0;
} // line 2 goes out of scope and destructs, then line 1 does the same

Answer 2

The compiler emits code that automatically calls the destructor when an object is explicitly destroyed (e.g. delete on an object created with operator new) or reaches the end of its defined life (e.g. a temporary destroyed when no longer needed, a declared variable passing out of scope).
In your code (as you have it at the time of my writing this) the sequence of events is
line1 is constructed
line2 is constructed as a copy of line1
line1 is passed by value to display(). This creates a temporary
copy of line1. When display() returns, the destructor is invoked for the temporary.
line2 is passed by value to display(). This creates a temporary
copy of line2. When display() returns, the destructor is invoked
for the temporary.
main() returns.
line1 and line2 are destructed in reverse order of their
construction, and destructor invoked for each.

Answer 3

So in line 1 (Main), why does it also call the copy constructor when
it has its own argument?
It will not call copy constructor, comment your code in main and try.
live_demo: http://coliru.stacked-crooked.com/a/64ad2d47a7ee953b
Also after the first call to the method display why is there another
call to the copy constructor ?
void display(Line obj)
When you invoke this function since your passing argument by value system creates a local copy of object named obj to function, it is happening using copy constructor of your class. This local objects scope will end as soon execution completes the scope of your function display.

Answer 4

Here is each part of main along with what it prints.
Line line1(10); //Line 1***************************
Normal constructor allocating ptr
Line line2 = line1; // This also calls copy constructor
Copy constructor allocating ptr.
display(line1);
Copy constructor allocating ptr.
Length of line : 10
Freeing memory!
display(line2);
Copy constructor allocating ptr.
Length of line : 10
Freeing memory!
return 0;
}
Freeing memory!
Freeing memory!
You are passing in Line by value so it copies the Line you have, calls the function and then the end of that function deletes the Line it got.