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

Because otherwise it would be passed by value, which is a copy, so you would need to invoke the copy constructor to invoke the copy constructor ...

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

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...

Answer 5

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;
}