为什么在调用重载的赋值运算符时调用了拷贝构造函数？

Question

i am trying to understand the use of constructors and assignment operators. I am trying with this below program.

#include <iostream>
using namespace std;

class myclass {
    int x;
public:
    myclass (int p) {
        cout << "calling constructor" << endl;
        x = p;
    }
    myclass () {
        cout << "calling constructor with no arguments" << endl;
        x = 0;
    }
    myclass (myclass &t) {
        cout << "calling copy constructor" << endl;
        x = t.x;
    }

    myclass operator=(myclass &t) {
        cout << "calling assignment operator" << endl;
        x = t.x;
        return *this;
    }

    void show () {
        cout << "val = " << x << endl;
    }
};


int main() {
    myclass a1;
    a1.show();
    myclass a2 = a1;
    a2.show();
    myclass a3(a2);
    a3.show();
    myclass a4(200);
    a2 = a4;
    a2.show();
    return 0;
}

Output:

calling constructor with no arguments // call 1
val = 0
calling copy constructor // call 2
val = 0
calling copy constructor // call 3
val = 0
calling constructor // call 4
calling assignment operator // call 5
calling copy constructor // call 6 i am not able to understand this print line
val = 200

call 1, is done from myclass a1;

call 2, is done from myclass a2 = a1;

call 3, is done from myclass a3(a2);

call 4, is done from myclass a4(200);

call 5, is done from a2 = a4;

but i am not able to get where call 6 is coming from, it is called from the instruction:

a2 = a4;

But, how it will give call to copy constructor?

any help/pointer wil be a great help. I am diving into cpp from c, hence please bear with me.

Answer 1

(You copy constructor and assignment operators are slightly malformed: they ought to take a const reference as the argument, and the assignment operator ought to return a reference not a value).

With myclass a2 = a1; , a2 doesn't yet exist. So the copy constructor is called to create a2 using a1 .

But with a2 = a4 , a2 already exists, so the assignment operator is used to assign a2 to a4 .

So the rule is essentially: If an object doesn't exist then it needs to be constructed. Your observed output can be explained by applying this rule.

Answer 2

 myclass operator=(myclass &t) {
    cout << "calling assignment operator" << endl;
    x = t.x;
    return *this;
}

The above function returns by value. Returning by value is one of the cases when copy constructor is called. Also AFAIK, this is not always true(returning by value calling copy constructor) as some compilers implement return value optimization.

Answer 3

change it to

myclass& operator=(myclass &t)

then:

calling constructor with no arguments
val = 0
calling copy constructor
val = 0
calling copy constructor
val = 0
calling constructor
calling assignment operator
val = 200

If you return by value, copy ctor will be called. Return by reference to avoid calling copy ctor.

Answer 4

Your assignment operator returns by value , so there's another copy made when it returns.

That's where the sixth call is coming from.

Typically, an assignment operator returns a reference instead, so that when you return *this , you really do return *this :

myclass& operator=(myclass &t) {
//     ^