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 (eg delete on an object created with operator new ) or reaches the end of its defined life (eg 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.