Error while passing argument number in operator overloading? - c++

Question

I want to add two objects. When I pass two arguments in operator overloading it gives me error that there must be zero or one argument. I want to know that why I can't pass two objects as argument in order to add them.
class Rectangle
{
private:
int L;
int B;
public:
Rectangle() //default constructor
{
L = 2;
B = 2;
}
Rectangle(int l,int b) //parametrized constructor
{
L = l;
B = b;
}
Rectangle operator+ (Rectangle obj1,Rectangle obj2) //operator overloading
{
Rectangle obj3
obj3.L = obj1.L + obj2.L;
obj3.B = obj1.B + obj2.B;
return obj3
}
void Display()
{
cout<< "length is " << L <<endl;
cout<< "breadth is " << B <<endl;
}
};
int main()
{
Rectangle R1;
R1.Display();
Rectangle R2(5,3);
R2.Display();
//Rectangle R3;
//R3 = R1 + R2;
//R3.Display();
return 0;
}

Answer 1

A binary operator like addition requires 2 operands. Overloading such an operator would mean that the overloaded method will work on 2 operands as well. The reason you need to provide only 1 parameter is in which scope you declared your overload, namely within Rectangle class. Basically, since that overload function is a member of Rectangle class, the left-hand side operator will be considered as this, the instance of the object itself. As a result, you merely need to provide the right-hand side operator as the parameter.
An alternative way to declare the functionality you have in mind would be overloading the addition operator outside the scope of Rectangle class. Then, you would indeed have to provide both the operands. But in that case you should mind the encapsulation. (i.e. find out a way to construct the resulting Rectangle instance without accessing only the public members of the Rectangle class) This consideration of encapsulation is one of the reasons why operators are commonly implemented as member functions, despite the parameter passing seeming counter intuitive to people who recently began learning an object oriented programming language.
This, however is fairly basic information on operator overloading, and I believe you should read up more on overloading, specifically on how overloading operators via member functions affect the overloading process.

Answer 2

In the code above, operator+ is a member function. In its declaration it has two named arguments; it also has an implied this pointer, because it's a member function. That makes three arguments. The compiler is saying that operator+ should take exactly one or exactly two arguments. That's because there are two possible forms of +, one unary and one binary. That is, you can write +2, which uses unary plus, or you can write 2+2, which uses binary plus.
This can be fixed in two different ways. One is to make it a static member function; that doesn't take a this pointer, so a static operator+ with two named arguments in fact takes two arguments.
A better approach is to make it a non-member function. Move it out of the class definition, and fix the error that comes from assigning to the data members of obj3. Rectangle has a constructor that takes two arguments; use it. You'll also have to add a way of getting the two values out, which you need regardless of how you implement this particular function. So it looks like this:
Rectangle operator+(Rectangle obj1, Rectangle obj2) {
Rectangle obj3(obj1.getL() + obj2.getL(), obj1.getR() + obj2.getR());
return obj3;
}
A more general approach is to provide operator+=(Rectangle obj), as a member function:
void operator+=(Rectangle obj) {
L += obj.L;
R += obj.R;
}
and use that to implement the non-member operator+:
Rectangle operator+(Rectangle obj1, Rectangle obj2) {
obj1 += obj2;
return obj1;
}