为什么在这个例子中调用了复制构造函数？

Question

I am very new to C++ and I don't understand why the copy constructor was called in the following code:

 #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 line(10);

   display(line);

   return 0;
}

And when it runs:

Normal constructor allocating ptr
Copy constructor allocating ptr.
Length of line : 10
Freeing memory!
Freeing memory!

Why does it construct an other Line object after the first one with the simple constructor?

Thanks!

Answer 1

because you are passing Line as value

void display(Line obj)
{
   cout << "Length of line : " << obj.getLength() <<endl;
}

You should pass it as constant reference, which is faster (and display shoud be a constant method so constant objects can call it).

void display(const Line &obj) const
{
   cout << "Length of line : " << obj.getLength() <<endl;
}

(provided that you change to int getLength( void ) const; )

And in your case, think of redefining assignment operator

Line &operator=(const Line &other);

or affecting a line in another will copy pointer data and will crash on your second object deletion since memory will be freed twice.

If you want to make sure that default copy constructor / assignment operator cannot be called, just declare them in your private part:

private:
  Line &operator=(const Line &other);
  Line(const Line &other);

code trying to use them won't compile.

Answer 2

Your display function takes a Line by value - meaning the function gets its own copy . If you don't want that, pass by (const) reference or pointer instead.

Answer 3

The answer is here:

void display(Line obj) { ...

The argument of the function obj is passed by value .

So when the function is called a copy of the argument passed by the caller function is done.

In order to give you a trivial explanation, imagine:

function:main (caller) -> 
make a copy of line ->
call the function display (callee) which is going to use the copy made by caller.

That policy is used in various case, for example :

• To be sure that the callee function will does any effect ( side-effect ) on the variables of the caller.
• When the callee function will perform a copy of the object, so you can avoid to make a copy inside the body function.

Because passing an argument by value will perform a copy of the argument itself, it is preferable using argument passed by reference .

This is an example:

void display(Line& obj) { ...

In that case it will not performed a copy of the object but the argument obj will be a reference (like a pointer) to the argument passed by the caller function.

In conclusion, passing by reference allows to callee function side effect , in other words the callee function can modify variables " owned " by caller function.

Answer 4

Copy constructors are called in following cases:

(a) when a function returns an object of that class by value

(b) when the object of that class is passed by value as an argument to a function

(c) when you construct an object based on another object of the same class

(d) When compiler generates a temporary object and is initialized with a class object.

And in your code you are passing the object of that clas by value as an argument to a function Hope this Helps