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

possible duplicate of Why should the copy constructor accept its parameter by reference in C++? — fredoverflow
– fredoverflow, Commented Mar 2, 2014 at 7:21

Brian Bi · Accepted Answer · 2014-03-02 03:19:43Z

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.

"No copy is made" by the copy assignment operator? Its purpose is to copy.
@Potatoswatter I meant to say copying is avoided when calling the function

user207421 · Accepted Answer · 2014-03-02 04:19:33Z

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

Ed Heal · Accepted Answer · 2014-03-02 03:08:13Z

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

ikh · Accepted Answer · 2014-03-02 03:23:05Z

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

For copy constructors there's actually a rule in the standard that prevents you from declaring X::X(X) or something similar.
Indeed, I didn't mean to suggest anything was lacking from your answer. :)

Potatoswatter · Accepted Answer · 2014-03-02 04:42:16Z

0

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

edited Mar 2, 2014 at 4:42

answered Mar 2, 2014 at 3:15

Potatoswatter

139k29 gold badges281 silver badges435 bronze badges

5 Comments

Ed Heal Over a year ago

... And it may be the same object

Benjamin Lindley Over a year ago

@BrianBi: No, not if an r-value argument was passed. It only has to be moved in that case.

Brian Bi Over a year ago

@BenjaminLindley point taken. Still, if an lvalue is passed then a copy will be made when calling the function, whereas if the parameter were a reference then that copy would be avoided, so I still don't see how this is "the best way in C++11".

Benjamin Lindley Over a year ago

@BrianBi: It's not necessarily the best way, but it is the preferred alternative if you don't want to write two assignment operators (a move assignment operator and a copy assignment operator). If you only have one version which takes a const l-value reference, then that will be used for r-values as well, resulting in unnecessary copying operations in the body. This relies on the general assumption that moves should be cheap relative to copies. An assumption which should hold for most well designed classes.

Potatoswatter Over a year ago

@BrianBi This function will perform either no copy if the caller says move, or one copy, and either one or two move-construction operations. In practice though, move construction of a short-lived object can usually be eliminated by lifetime analysis.

Collectives™ on Stack Overflow

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

5 Answers 5

2 Comments

Comments

Comments

3 Comments

5 Comments

Linked

Hot Network Questions

Collectives™ on Stack Overflow

5 Answers 5

2 Comments

Comments

Comments

3 Comments

5 Comments

Linked

Related