2

The other day, I ran into trouble when I tried to overload a two-parameter operator with the use of a class member function. I tried references, but nothing changed. The compiler said I couldn't write a member function that takes more than one argument of the same type as the class itself. Why is that?

Here is the code:

class Fraction
{
public:
  Fraction(int num=1, int den=1): numerator(num), denominator(den) {}
  Fraction(const Fraction& r): numerator(r.numerator), denominator(r.denominator) {}
  Fraction& operator=(const Fraction&);
  Fraction& operator*(const Fraction&, const Fraction&);
private:
  int numerator, denominator;
};

Fraction& Fraction::operator=(const Fraction& r)
{
  numerator = r.numerator;
  denominator = r.denominator;
  return *this;
}

Fraction Fraction::operator*(const Fraction& x, const Fraction& y)
{
  Fraction z(x.numerator*y.numerator, x.denominator*y.denominator);
  return z;
}

The following is the error message from the compiler:

Fraction& Fraction::operator*(const Fraction&, const Fraction&)' must take either zero or one argument

axcelenator
  • 1,497
  • 3
  • 18
  • 42
Mo Sanei
  • 445
  • 6
  • 22
  • 5
    You should illustrate this with some small code sample. It sounds like you misunderstood the compiler error. – juanchopanza Jun 05 '13 at 17:29
  • Please give us some code, and the exact error the compiler gives you :) – Imane Fateh Jun 05 '13 at 17:30
  • It can. Post code and error messages. – John Dibling Jun 05 '13 at 17:32
  • @juanchopanza No I didn't! – Mo Sanei Jun 05 '13 at 18:06
  • You did, in fact, misunderstand the compiler, because the compiler **isn't** saying you can't define a member function that takes more than one argument of the same type as the class itself (anymore than it's saying you can't define a member function that takes an argument that starts with `F`). What it's telling you is that operator `*` is a binary operator, and therefore can only take one argument when defined as a member function (where the first argument is implicitly `this`) – Charles Salvia Jun 05 '13 at 19:33
  • 1
    "The compiler said I couldn't write a member function that takes more than one argument of the same type as the class itself." No it didn't, it said you couldn't write `operator*` with more than one argument. – Bill Jun 05 '13 at 19:34
  • Thank you all for your answers. – Mo Sanei Jun 06 '13 at 06:49

2 Answers2

4

The operators take a fixed amount of arguments, for example operator+ as the addition operator takes exactly 2 parameters. If it is a member function the first(leftmost) is implied to be this and the second is passed as a parameter.

What would calling an operator+ that took three parameters look like? One might imagine it would look like 3 + 4 + 5 but that is the equivalent of calling operator+(3,4) then operator+(7,5).

For a list of operators and how many arguments they take please check out wikipedia: http://en.wikipedia.org/wiki/Operators_in_C_and_C%2B%2B

For more details there is another StackOverflow post that goes into great detail: Operator overloading

Community
  • 1
  • 1
Sqeaky
  • 1,876
  • 3
  • 21
  • 40
  • I think that he has the wrong number of parameters, if I am wrong or misunderstood, sorry. – Sqeaky Jun 05 '13 at 17:52
  • Thanks for the information but what I want to know is why I can't declare a class member function that takes more than one argument **of the same type as the class**. – Mo Sanei Jun 05 '13 at 18:57
  • 2
    @MohammadSanei you can. But multiplication `operator*` is an exception, because it should take 2 arguments in total, including the implicit first parameter. – juanchopanza Jun 05 '13 at 19:24
  • 2
    * is a binary operator which means it takes two (and only two) arguments. When it's defined as a class member function, the left hand side argument is implicitly `*this`, so it only takes one argument. Also, you're returning a reference to a temporary in your implementation, which is undefined behavior – Charles Salvia Jun 05 '13 at 19:37
  • Thank you juanchopanza & Charles Salvia. – Mo Sanei Jun 06 '13 at 06:54
2

Firstly, the issue you are observing has absolutely nothing to do with member functions in general. Member functions can generally take arbitrary number of arguments of "same class" type. In your example you can declare

class Fraction
{
   void foo(Fraction &f1, Fraction &f2, Fraction &f3, Fraction &f4) {}
   ...
};

without any problems. So, it is not clear why you decided to word your question as if it is about member functions in general.

Secondly, in your code it is really about the simple fact that you are trying to overload an operator. Operator syntax in C++ is fixed for most (but not all) operators. This immediately means that those operators whose syntax is fixed will have fixed number of parameters.

In your example, it is operator *. It can be unary (one parameter) or binary (two parameters). When you overload this operator by a member function one parameter is already implied, so you can only add zero or one additional parameters (for unary * and binary * respectively). You, on the other hand, are trying to add two more parameters in additions to the implicit one. I.e. you are trying to define a ternary operator *. This is not possible. There's no ternary * operator in C++. And this is exactly what the compiler is telling you.

AnT stands with Russia
  • 312,472
  • 42
  • 525
  • 765