Too many parameters for this operator function

[Shervan360]

Hello,

I don't want to use a friend keyword for + operator overloading.
I have an error in line 35.

How can I fix it?

Thanks

#include <iostream>
using namespace std;

class Fraction
{
private:
	int numerator;
	int denominator;

	Fraction Add(Fraction f1, Fraction f2)
	{
		int denominator3 = gcd(f1.denominator, f2.denominator);

		denominator3 = (f1.denominator * f2.denominator) / denominator3;

		int numerator3 = (f1.numerator) * (denominator3 / f1.denominator) + (f2.numerator) * (denominator3 / f2.denominator);
		Simplify(numerator3, denominator3);
		Fraction f; f.numerator = numerator3; f.denominator = denominator3;
		return f;
	}

	int gcd(int a, int b) {
		if (a == 0 || b == 0)
			return 0;
		else if (a == b)
			return a;
		else if (a > b)
			return gcd(a - b, b);
		else return gcd(a, b - a);
	}
public:
	friend ostream& operator<<(ostream& os, const Fraction& f);
	friend istream& operator>>(istream& in, Fraction& f);

	Fraction operator + (Fraction const &f1, Fraction& const f2) // ERROR -   Too many parameters for this operator function

	{
		 return Add(f1, f2);
	}

	void Simplify(int n, int d)
	{
		int myGcd = gcd(n, d);
		n = n / myGcd;
		d = d / myGcd;
	}

};
ostream& operator<<(ostream& os, const Fraction& f)
{
	os << f.numerator << "/" << f.denominator << endl;
	return os;
}
istream& operator>>(istream& in, Fraction& f)
{
	cout << "Numerator: ";
	in >> f.numerator;
	cout << "Deniminator: ";
	in >> f.denominator;

	return in;
}
int main()
{
	Fraction f1;
	Fraction f2;

}

[keskiverto]

Operators are syntactic sugar that allow you to write

lhs op rhs
// rather than
op( lhs, rhs )

Member functions have implicit parameter:

obj.mem( param );
// rather than
T func( U *this, V param );
func( &obj, param );

You have written
Fraction Fraction::operator+ (Fraction const &f1, Fraction& const f2)
That would correspond to standalone
Fraction operator+ ( Fraction &obj, Fraction const &f1, Fraction& const f2)
Would you write:

Fraction f1;
Fraction f2;
Fraction f3;
Fraction f4;
f4 = f3 + f1 f2; // ???? 

Solution for binary operators:

Fraction Fraction::operator op ( Fraction& const rhs ) const
{
  // lhs IS *this
  // ...
}

Canonical way to write those operators is standalone, implemented with member compound operators:

Fraction operator + ( Fraction lhs, const Fraction& rhs )
{
  lhs += rhs
  return lhs;
}

Requires public member:

Fraction& Fraction::operator += ( Fraction& const rhs )
{
  // ...
}