C + + about operator overloading knowledge points

1) except for the generic relational operator ".", the member pointer operator ". *", The scope operator "::", the sizeof operator and the three-mesh operator "?:", all operators in C + + can be overloaded.

(2) Overloaded operators restrict the allowed overloaded operators in the range of operators that are already in the C + + language, and cannot create new operators.

(3) Operator overloading is essentially a function overload, so the compiler's choice of operator overloading follows the selection principle of function overloading.

(4) An overloaded operator cannot change the precedence and binding of an operator, nor can it change the number of operator operands and the syntax structure.

(5) Operator overloading cannot change the meaning of the operator for an intrinsic type object. It can only be used with objects of user-defined types, or when mixed with objects of the user-defined type and internal types.

(6) Operator overloading is the proper modification of the original operator for the actual need for the new type of data, and the overloaded functionality should be similar to the original functionality, avoiding the use of overloaded operators without destination.

　
operator function overloading generally has two forms: overloading the member functions of the class and overloading the non-member functions of the class. A non-member function is usually a friend.
(an operator can be overloaded as a non-member, non-friend function.) However, when such an operator function accesses the private and protected members of a class,
You must use the Set data and the function that reads the data provided in the public interface of the class, which degrades performance when these functions are called. These functions can be inline to improve performance.

The general format of operator overloading for member functions of a class is:

< function type > operator < operator > (< parameter table >)

{

< function body >

}

When an operator is overloaded with a member function of a class, the number of arguments to the function is one less than the original operand (except for the post-order operator).
This is because the member function implicitly accesses an object of the class with the this pointer, which acts as the leftmost operand of the operator function. So:

(1) When the binocular operator is overloaded as a member function of a class, the function explicitly describes only one parameter, which is the right operand of the operator.

(2) When the pre-order operator is overloaded as a member function of a class, there is no need to explicitly describe the parameter, that is, the function has no formal parameters.

(3) When the post-order operator is overloaded with a member function of a class, the function takes an integer parameter.

The calling member function operator is in the following format:

< object name >.operator < operator > (< parameters >)

It is equivalent to

< object names >< operators >< parameters >

For example: A+b is equivalent to A.operator + (b). In general, we use the idiomatic expressions of operators.
Friend function operators

The general format of the friend function for an operator overload for a class is:

Friend < function type > operator < operator > (< parameter table >)

{

< function body >

}
When an operator is overloaded with a friend function of a class, there is no change in the number of operands because there is no implied this pointer.
All operands must be passed through the formal parameters of the function, and the arguments of the function correspond to the operands from left to right.

The format of the function operator is as follows:

Operator < operator > (< parameter 1>,< parameter 2>)

It is equivalent to

< parameter 1>< operator >< parameter 2>

For example, A+b is equivalent to operator + (A, b).
Comparison of two types of overloaded forms

In most cases, overloading the operator with the member function of the class and the friend function of the class is possible. But the member function operator and the friend function operator also have their own characteristics:

(1) In general, the monocular operator is best to overload the member function of the class; The binocular operator is best to overload the friend function of the class.

(2) Some of the following binocular operators cannot be overloaded with the friend function of a class: =, (), [], and.

(3) A type conversion function can only be defined as a member function of a class and cannot be defined as a friend function of a class.

(4) If the operation of an operator needs to modify the state of an object, it is preferable to select overload for the member function.

(5) If the operand required by the operator (especially the first operand) wishes to have an implicit type conversion, only the friend function is selected.

(6) When an operator function is a member function, the leftmost operand (or only the leftmost operand) must be a class object of the operator class (or a reference to the class object).
If the operand on the left must be a non-homogeneous object, or an object of an intrinsic type, the operator function must be implemented as a friend function.

(7) When an overloaded operator is required to be exchangeable, select overload as a friend function.

C + + about operator overloading knowledge points