Using overloaded operators

Hi guys

Please take a look at this example:

Code:

---

class X {
public:

  // member prefix ++x
  void operator++() { }
};

class Y { };

// non-member prefix ++y
void operator++(Y&) { }

int main() {
  X x;
  Y y;

  // calls x.operator++()
  ++x;

  // explicit call, like ++x
  x.operator++();

  // calls operator++(y)
  ++y;

  // explicit call, like ++y
  operator++(y);
}

---

Please note that when using the overloaded operator for an instance of X, we can call it using

Code:

---

x.operator++()

---

In the case with the overloaded operator ++ for an instance of Y (it is overloaded using a non-member function), we can call it using

Code:

---

operator++(y)

---

My question is: Is there any reasoning behind the fact that we cannot call the two operators using the same syntax? Or is that just the way it is?

Best,
Niles.

Quote:

---

Originally Posted by Niels_M

Is there any reasoning behind the fact that we cannot call the two operators using the same syntax?

---

But you can, i.e., ++x and ++y ;)

Besides that, please take a look at this example:

Code:

---

class X {
public:

  // member function foo
  void foo() { }
};

class Y { };

// non-member function foo
void foo(Y&) { }

int main() {
  X x;
  Y y;

  x.foo();

  foo(y);
}

---

Please note that when using the function foo for an instance of X, we can call it using

Code:

---

x.foo();

---

In the case with the function foo for an instance of Y (it is declared as a non-member function), we can call it using

Code:

---

foo(y);

---

My question is: Is there any reasoning behind the fact that we cannot call the functions using the same syntax? Or is that just the way it is?

Quote:

---

Originally Posted by laserlight

But you can, i.e., ++x and ++y ;)

---

Ah, yes. Of course.

Quote:

---

Originally Posted by laserlight

Besides that, please take a look at this example:

Code:

---

class X {
public:

  // member function foo
  void foo() { }
};

class Y { };

// non-member function foo
void foo(Y&) { }

int main() {
  X x;
  Y y;

  x.foo();

  foo(y);
}

---

Please note that when using the function foo for an instance of X, we can call it using

Code:

---

x.foo();

---

In the case with the function foo for an instance of Y (it is declared as a non-member function), we can call it using

Code:

---

foo(y);

---

---

I see, very good explanation. Thanks!

Best,
Niles.