C + + Copy constructors and overloaded assignment operators invoke each other analysis [go]

Conclusion:
From the perspective of object programming, the copy constructor calls the overloaded assignment operator, and the overloaded assignment operator calls the copy constructor without meaning. should be avoided.

Don ' t try to implement one of the copying functions in terms of the other. Instead, put common functionality in a third function, this both call.

--effective C + + third Edition by Scott Meyers Item 12:copy All parts of a object things to Remember

First, it is clear that the existence meaning of the copy constructor is to construct a new object through the existing object, and then only two objects are constructed; the meaning of the overloaded assignment operator is to assign the value of one object to another object, and two objects are already constructed.

Copy constructor call overload assignment operator: assigns the value of an existing object to an object in a construct, although the object's memory is already allocated. (acceptable, but it is possible to cause cyclic calls to overloaded assignment operators and copy constructors)

The overloaded assignment operator invokes the copy constructor: Copies the existing objects and assigns them to the object. --One more temporary object, and causes the loop to call the overloaded assignment operator.

Example 1: Copy constructor call overload assignment operator (causes loop call overload assignment operator and copy constructor)

2. #include <iostream>
4. Using namespace std;
8. Class Base {
10. Public
12. Base () {cout << "Constructor invoked!" << Endl;}
14. ~base () {cout << "destructor invoked!" << Endl;}
16. Base (const base& RHS) {
18. cout << "Copy constructor invoked!" << Endl;
20. Operator= (RHS);  //*this = RHS;
22. }
24. Base operator= (const base& RHS) { //The problem is here, the return value is not a reference will call the copy constructor
26. cout << "Copy assignment operator invoked!" << Endl;
28. return * this;
30. }
32. };
36. int main (int argc, char** argv) {
38. cout << "Hello World c++!" << Endl;
40. Base A;
42. Base B (a);  //Base B = Base (a);
44. return 0;
46. }

After modification

2. #include <iostream>
4. Using namespace std;
8. Class Base {
10. Public
12. Base () {cout << "Constructor invoked!" << Endl;}
14. ~base () {cout << "destructor invoked!" << Endl;}
16. Base (const base& RHS) {
18. cout << "Copy constructor invoked!" << Endl;
20. Operator= (RHS);  //*this = RHS;
22. }
24. base& operator= (const base& RHS) { //return reference, can accept
26. cout << "Copy assignment operator invoked!" << Endl;
28. return * this;
30. }
32. };
36. int main (int argc, char** argv) {
38. cout << "Hello World c++!" << Endl;
40. Base A;
42. Base B (a);  //Base B = Base (a);
44. return 0;
46. }

This does not have any problem, but it destroys the meaning of the copy constructor (different people may understand the difference), so it is not recommended.

If you think the copy constructor body needs to be assigned this way, Ok, there's no problem with that. Please continue.

Example 2: Overloaded assignment operator calls copy constructor (causes loop call overload assignment operator)

2. #include <iostream>
4. Using namespace std;
8. Class Base {
10. Public
12. Base () {cout << "Constructor invoked!" << Endl;}
14. ~base () {cout << "destructor invoked!" << Endl;}
16. Base (const base& RHS) {
18. cout << "Copy constructor invoked!" << Endl;
20. }
22. base& operator= (const base& RHS) {
24. cout << "Copy assignment operator invoked!" << Endl;
26. * This= Base (RHS);
28. return * this;
30. }
32. };
36. int main (int argc, char** argv) {
38. cout << "Hello World c++!" << Endl;
40. Base A;
42. Base B (a);  //Base B = Base (a);
44. b = A;
46. return 0;
48. }

Or that sentence:

• Don ' t try to implement one of the copying functions in terms of the other. Instead, put common functionality in a third function, this both call.

The copy constructor uses an existing object to construct an object that does not exist (after all, the copy constructor is a constructor), which is the initialization of an object. The overloaded function of an assignment operator is to assign a value to another object that already exists and is initialized (that is, the constructor has been initialized).  

For example: String S1 ("Hello"), s2=s1;//copy constructor

sring S1 ("Hello"), S2;

s1=s2;//assignment operator overloading

The copy constructor is called in the following cases:

1. An object is passed into the function body as a value (combined with formal parameters and arguments)

2, an object is returned as a value from the function (the function returns

3, an object needs to be initialized by another object.

C + + Copy constructors and overloaded assignment operators invoke each other analysis [go]