Looking at C ++ from the perspective of Assembly (the arithmetic operator overload trap) 23

[Disclaimer: All Rights Reserved. You are welcome to reprint it. Do not use it for commercial purposes. Contact Email: feixiaoxing @ 163.com]

 

In Arithmetic Operator overloading, the "=" overload may be the most frequently used one. However, many people mistakenly think that in a function, where "=" occurs in a class, it is to call the arithmetic operator to overload it. In fact, this is not the case. Why? Let's take a look at the followingCode. First, we define a basic class:

[CPP] View plaincopy

2. ClassData
4. {
6. Char* Value;
8. IntNumber;
10. Public:
12. ExplicitData (IntNum = 0 ){
14. If(Num ){
16. Number = num;
18. Value = (Char*) Malloc (Num );
20. }
22. }
26. Data (ConstData & D ){
28. Number = D. get_number ();
30. Value = (Char*) Malloc (D. get_number ());
32. Memmove (value, D. get_point (), D. get_number ());
34. }
38. ~ Data (){
40. If(Number)
42. Free (value );
44. }
48. Data & operator = (ConstData & D ){
50. If(Number)
52. Free (value );
54. Number = D. get_number ();
56. Value = (Char*) Malloc (D. get_number ());
58. Memmove (value, D. get_point (), D. get_number ());
60. Return*This;
64. }
68. IntGet_number ()Const{ReturnNumber ;}
70. Char* Get_point ()Const{ReturnValue ;}
72. };

After the function is defined, we start to call this class. The same Code is as follows:

[CPP] View plaincopy

2. 45: Data M (10 );
4. 0040108d push 0ah
6. 0040366f Lea ECx, [ebp-14h]
8. 00401092 call @ ILT + 30 (data: Data) (00401023)
10. 00401097 mov dword ptr [ebp-4], 0
12. 46: Data P = m;
14. 0040da-e Lea eax, [ebp-14h]
16. 004010a1 push eax
18. 004010a2 Lea ECx, [ebp-1Ch]
20. 004010a5 call @ ILT + 35 (data: Data) (00401028)
22. 004010aa mov byte PTR [ebp-4], 1
24. 47: P = m;
26. 004010ae Lea ECx, [ebp-14h]
28. 004010b1 push ECx
30. 004010b2 Lea ECx, [ebp-1Ch]
32. 004010b5 call @ ILT + 5 (data: Operator =) (0040100a)
34. 48 :}

There are three sentences above. We will analyze them one by one:

A temporary variable is defined to call the data constructor.

46: A Temporary Variable P is displayed. It is found that the data class does not call the arithmetic operator to overload the function, but calls the data constructor, as shown in 45 sentences, the called constructor is definitely not a common constructor, so the rest of the results can only be a copy of the constructor.

47: The Code of 46 sentences is the same, but the called function is the arithmetic operator to overload the function.

Therefore, where "=" occurs, it is not always an arithmetic operator overload function, or a copy constructor. So when is the copy constructor and when is the arithmetic operator reload function? The judgment criteria are actually very simple. If the temporary variable appears for the first time, only the copy constructor can be called. If the variable already exists, just like 47 sentences, only the arithmetic operator overload function can be called, however, the arithmetic operator overload function we defined here has a trap. Do you know it?

I would like to remind you that the overload of Arithmetic Operators here does not need to judge whether the copied operators are themselves?

[CPP] View plaincopy

1. VoidProcess ()
2. {
3. Data M (10 );
4. Data P = m;
5. P = P;
6. }

In the last sentence, if the arithmetic operator can be copied to itself, the code can be compiled and run normally, but in some cases many unexpected situations may occur. You can follow my ideas:

[CPP] View plaincopy

2. Data & operator = (ConstData & D ){
4. If(This==& D)/* Check whether it is self-copy action */
6. Return*This;
10. If(Number)
12. Free (value );
14. Number = D. get_number ();
16. Value = (Char*) Malloc (D. get_number ());
18. Memmove (value, D. get_point (), D. get_number ());
20. Return*This;
24. }

If the code above does not determine whether the Copied object is itself, we find that the data of the actually value is actually free. In this case, the memory is re-allocated, and the copied data only knows what the data is. There is a lot of uncertainty in the memory space that the original value points to, which is the trap of overloading Arithmetic Operators.

 

[Note: since the end of the C ++ series with compilation, we will start the data structure andAlgorithmFor more information, see]