Why should the parameter to a copy assignment operator should be a reference?

Question

"opperator= should takes a parametor of the (of course,const best) ref of src obj",i see this in many books,but i try to use non-ref instead,it also works!so,whats the purpose of using ref?is it just to avoid copy from the param? my test code are,

#include <iostream>
#include <string>
using namespace std;

class Student{
public:
    Student& operator=(Student);
    string name;
    int num;
};

Student& Student::operator=(Student s)
{
    name=s.name;
    num=s.num;
    return *this;
}

int main(){
Student src;
src.name="haha";
src.num=11;
cout<<src.name<<" "<<src.num<<endl;
Student dst=src;
cout<<src.name<<" "<<src.num<<endl;
}

Answer 1

There are really two issues here:

1) The copy-assignment operator you've defined doesn't get called . The line

Student dst=src;

doesn't call the copy-assignment operator! It calls the copy constructor , which is defined implicitly by the compiler. However, if you wrote

Student dst;
dst = src;

then operator= would be called.

2) Yes, the purpose is to avoid copying. When you call a function, including operator= , which takes a Student by value, the Student object argument has to be copied (through an implicit call to the copy constructor). If the function takes a reference, on the other hand, then no copy is made.

Answer 2

因为否则它将通过值传递，这是一个副本，因此您需要调用复制构造函数来调用复制构造函数...

Answer 3

This

Student& Student::operator=(Student s)
{
    name=s.name;
    num=s.num;
    return *this;
}

Should be

Student& Student::operator=(const Student &s)
{
    if (this == &s) return *this;
    name=s.name;
    num=s.num;
    return *this;
}

Use references to avoid wastage of CPU

Answer 4

In C++03, passing by const reference avoids making a potentially expensive new copy just for the local s , which is never modified, in addition to copying s into the destination object.

In C++11, now we have move semantics: Assignment may result in resource transfer to a new object, or resource copying. The pass-by-copy operation can be leveraged to produce the copied data which is used for the destination object, so the overhead is put to good use. If you pass using move , there is no copy. The best practice in C++11 is to let a single function serve as both the copy and move assignment operator:

Student& Student::operator=(Student s)
{
    name = std::move( s.name );
    num = s.num;
    return *this;
}

Answer 5

Simple. Look at this code.

Student a, b;
a = b;

it is equal to

a.operator=(b);

and b is passed by value. so the copy constructor is called.

a.operator=(Student(b)); // please notice that it is just psudo code..

Therefore, there are two copying! One is copy constructor , and the other is copy assignment operator . It is unnecessary.

---

Moreover, copy constructor 's param must be reference, too. Otherwise, the infinite recursion occurs because call-by-value requires copying and copying requires call-by-value and...