What are the methods of operator overloading in C++?

c What are the methods of operator overloading?

There are two methods to overload operators:
1. Make overloading operations symbol becomes a member function of this class. This allows operator functions to access private members of the class. It also allows functions to use the implicit this pointer parameter to access the calling object.

2. Make the overloaded member function an independent function. When overloaded in this manner, the operator function must be declared a friend of the class in order to access the private members of the class.
Certain operators (such as the stream input operator >> and the stream output operator <<) must be overloaded as independent functions. Other operators can be overloaded either as member functions or as stand-alone functions.
Assume that the following independent overloaded function code has been written:

Length a(4, 2), b(1, 8), c (0);
c = a + b;

This code will be interpreted by the compiler as the following form:

Length a(4, 2), b(1, 8), c(0);
c = operator+(a, b);

The compiler allows programmers to use friendly Intermediate caret. However, it treats the operator as an ordinary function with the name operator , which has a not-so-obvious meaning. For example, consider the following statement:

c = 2 + a;

is equivalent to the following statement:

c = operator+(2, b);

Both statements compile and execute correctly because of the conversion constructor of the Length class A Length object can be created out of the integer parameter 2.

Overloading of arithmetic and relational operators can be as easy as overloading of member functions. The overloading methods of the addition operator are as follows. First, modify the in-class declaration so that the operator becomes a member function:

class Length
{
    private:
        int len_inches;
    public:
        //修改operator+的声明
        Length operator+(Length b);
        //类的其余部分，省略
};

Note that the operator is now declared as a single operator of type Length because as A member function, the operator is automatically passed a Length object through the implicit parameter this. For example, if you write the following statement:

Length a(4, 2), b(1, 8), c(0);
c = a + b;

The compiler will treat this statement as something of the form:

Length a(4, 2), b(1, 8), c (0);
c = a.operator+ (b);

When writing a b, the left hand side of the overloaded operator The operand becomes the object to call the member function, and the right operand becomes an explicit parameter. Along with these changes, the body of the operator is written as a statement of the following form:

Length Length::operator+(Length b)
{
    return Length(this->len_inches + b.len_inches);
}

In summary, the addition operator (as well as other arithmetic and relational operators) can be used as a member function , can also be overloaded as an independent function.
Generally speaking, it is better to overload binary operators into independent functions that use the same type of formal parameters. This is because, unlike overloading of standalone operators, overloading of member functions creates an artificial distinction between the two parameters by making the left-hand parameter implicit, which will allow the conversion constructor to apply the right side parameters, but the left-hand parameter is not used, resulting in a situation where the order of the parameters is changed, resulting in a compiler error in the correct program if it is changed. Examples are as follows:

Length a(4, 2), c(0);
c = a + 2; //编译，当于 c = a.operator+ (2)
c = 2 + a; //不能编译：相当于 c = 2 .operator+ (a);

Recommended tutorial: "c "

The above is the detailed content of What are the methods of operator overloading in C++?. For more information, please follow other related articles on the PHP Chinese website!