A question about the overloaded operator +

冷夜星光

The operator + () function can not be defined as a member function or a friend function. What is the difference between the two cases?
Thank you!

firegun

Suppose the class BigInt is a large number processing class
BigInt has BigInt(int i) constructor
BigInt temp;
BigInt temp2 = 2 + temp;
Member functions cannot implicitly convert 2 to BigInt, friend functions can

firegun

It should be said that for member function overloading +, this sentence is equivalent to:
BigInt temp2 = 2.operator+(temp);
This is a wrong sentence

sinsun123

Operators that are members have one less parameter in the form of declaration and definition than operators that are not members. This is because c++
The first parameter this is hidden from all member functions

Similarly, the overloaded operator as a member function is also one more than the function parameter as a friend. Take the operator +, for example, in the member function, its first parameter is the object it belongs to, the second Is a parameter, and in the friend function, both objects are parameters
The statement is as follows
Member function version: SomeClass operator + (SomeClass)
Friends function version: friend SomeClass operator + (SomeClass, SomeClass)
Someclass is a class name, assuming that both functions return SomeClass objects.

冷夜星光

So there are so many reasons inside! Thank you!

orangedj

Well, parameters can be implicitly type-converted, an object cannot. It is recommended to look at effective c++ Item19

天魔狂舞

Member function has a latent parameter.
Friend function does't.

zhoudaj

If you want to put the object on the left side of the operator, then you can not use member function

fcuptfwfn

Binocular operator is best to use friend function, member function for monocular

zfy010317

Member definitions have more restrictions, because the default specifications are:
operator+ (int) const -----> operator+ (T const&, int) const;

There are not so many restrictions on friends, you can revise the two parameters separately and make some adjustments, etc.
operator+ (T const&, int)
operator+ (int, T const&)

From the perspective of overloading, friends are more flexible.
However, it is more pleasant to use members or members.