Overloading the comparison operators is simple once you’ve learned how to overload the arithmetic operators.

Because the comparison operators are all binary operators that do not modify their operands, we will make our overloaded comparison operators friend functions.

Here’s an example Point class from the previous lesson with an overloaded operator== and operator!=.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
class Point { private: double m_dX, m_dY, m_dZ; public: Point(double dX=0.0, double dY=0.0, double dZ=0.0) { m_dX = dX; m_dY = dY; m_dZ = dZ; } friend bool operator== (Point &cP1, Point &cP2); friend bool operator!= (Point &cP1, Point &cP2); double GetX() { return m_dX; } double GetY() { return m_dY; } double GetZ() { return m_dZ; } }; bool operator== (Point &cP1, Point &cP2) { return (cP1.m_dX == cP2.m_dX && cP1.m_dY == cP2.m_dY && cP1.m_dZ == cP2.m_dZ); } bool operator!= (Point &cP1, Point &cP2) { return !(cP1 == cP2); } |

The code here should be straightforward. Because the result of operator!= is the opposite of operator==, we define operator!= in terms of operator==, which helps keep things simpler, more error free, and reduces the amount of code we have to write.

It doesn’t really make sense to overload operator> or operator< for the Point class. What does it mean for a 3d point to be greater or less than another point? Greater than or less than isn't a concept we normally apply to 3d points, so it's better not to include those operators in the Point class, because the results of the operators (whatever you define them to be) would not be intuitive. Here's a different example with an overloaded operator>, operator<, operator>=, and operator<=:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
class Cents { private: int m_nCents; public: Cents(int nCents) { m_nCents = nCents; } friend bool operator> (Cents &cC1, Cents &cC2); friend bool operator<= (Cents &cC1, Cents &cC2); friend bool operator< (Cents &cC1, Cents &cC2); friend bool operator>= (Cents &cC1, Cents &cC2); }; bool operator> (Cents &cC1, Cents &cC2) { return cC1.m_nCents > cC2.m_nCents; } bool operator<= (Cents &cC1, Cents &cC2) { return cC1.m_nCents <= cC2.m_nCents; } bool operator< (Cents &cC1, Cents &cC2) { return cC1.m_nCents < cC2.m_nCents; } bool operator>= (Cents &cC1, Cents &cC2) { return cC1.m_nCents >= cC2.m_nCents; } |

This is also pretty straightforward. Note that there is some redundancy here as well. operator> and operator<= are logical opposites, so one could be defined in terms of the other. operator< and operator>= are also logical opposites, and one could be defined in terms of the other. In this case, I chose not to do so because the function definitions are so simple, and the comparison operator in the function name line up nicely with the comparison operator in the return statement.

9.5 -- Overloading unary operators +, -, and ! |

Index |

9.3 -- Overloading the I/O operators |

operator> is defined twice; operator< is missing.

[ Fixed! -Alex ]

Could you make an example to show how you can use one of the overloaded operators?

Sure.

thanks Alex very mutch i love you totorile

simple &easy

Shouldn’t all of the arguments to the operator overload functions be const?

Yes, you’re right, I think. If they aren’t const, then those operators can’t be used on const variables even though there is no real reason they shouldn’t, since they don’t actually change the variable values.

Great tutorial as usual. Just as an idea the < and > operators could be used to compare the magnitude of the vector from the origin to the point in the Point class.

Wouldn’t the functions in the first example always return wrong result due to small rounding errors in double comparison?

int main()

{

using namespace std;

Cents a(80);

Cents b(100);

if (a > b)

cout << "A is GREATER THAN B";

else

cout << "B is GREATER THAN A" << endl;

cout << "===================================" << endl;

Cents x(80);

Cents y(78);

if (x <= y)

cout << "X is LESS THAN OR EQUAL TO Y";

else

cout << "Y is LESS THAN OR EQUAL TO X" << endl;

cout << "===================================" << endl;

Cents ict1(80);

Cents ict2(200);

if (ict1 < ict2)

cout << "ICT1 is LESS THAN ICT2" <<endl;

else

cout << "ICT2 is LESS THAN ICT1" << endl;

cout << "===================================" <= ict4)

cout << "ICT3 is GREATER THAN OR EQUAL TO ICT4";

else

cout << "ICT4 is GREATER THAN OR EQUAL TO ICT3";

cin.get();

return 0;

// working okay by ifycent2 de ict

}

Thank Info..

Why can’t I overload operator ‘~=’ same way I overload ‘==’? I want it to have same definition as ‘!=’.

It gives error "declaration of ‘operator~’ as non-function". Is it an error with my syntax?

I read somewhere that C++ overloads operators whose definitions are already known? Is that true? For example can’t overload definition of ‘#’ operator. Or define my own operator.

my code:

In C++, you can only overload operators that already exist in C++. ~= isn’t an operator that naturally exists in C++, so you can’t overload it.

"operator> and operator<= are logical opposites, so one could be defined in terms of the other. operator< and operator>= are also logical opposites"

shouldn’t it be:

"operator> and operator< are logical opposites, so one could be defined in terms of the other. operator<= and operator>= are also logical opposites"

(last paragraph)

No, it’s correct as written. Logical opposites should always return opposing boolean values (one returns true, the other false).

Consider what happens if we compare the values 5 and 5:

5 > 5 is false

5 < 5 is false

Thus, these are not opposites.

Yup, got it. I am extremely stupid

Why we have to overload relational operators in pairs ?

like if I overload == I must overload !=

Thanks

You don’t have to. However, since one can be defined in terms of the other, it’s almost trivial to write the second after you have the first.