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.

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?

Originally Posted by laserlight

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

Ah, yes. Of course.

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.