Overloading unary operators
Unlike the operators you’ve seen so far, the positive (+), negative (-) and logical not (!) operators all are unary operators, which means they only operate on one operand. Because none of these operators change their operands, we will be implementing them as friend functions. All three operands are implemented in an identical manner.
Let’s take a look at how we’d implement operator- on the Cents class we used in a previous example:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| class Cents{private: int m_nCents;public: Cents(int nCents) { m_nCents = nCents; } // Overload -cCents friend Cents operator-(const Cents &cCents);};// note: this function is not a member function!Cents operator-(const Cents &cCents){ return Cents(-cCents.m_nCents);} |
This should be extremely straightforward. Our overloaded negative operator (-) takes one parameter of type Cents, and returns a value of type Cents.
Here’s another example. The ! operator is often used as a shorthand method to test if something is set to the value zero. For example, the following example would only execute if nX were zero:
1
2
| if (!nX) // do something |
Similarly, we can overload the ! operator to work similarly for a user-defined class:
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
35
36
37
| 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; } // Convert a Point into it's negative equivalent friend Point operator- (const Point &cPoint); // Return true if the point is set at the origin friend bool operator! (const Point &cPoint); double GetX() { return m_dX; } double GetY() { return m_dY; } double GetZ() { return m_dZ; }};// Convert a Point into it's negative equivalentPoint operator- (const Point &cPoint){ return Point(-cPoint.m_dX, -cPoint.m_dY, -cPoint.m_dZ);}// Return true if the point is set at the originbool operator! (const Point &cPoint){ return (cPoint.m_dX == 0.0 && cPoint.m_dY == 0.0 && cPoint.m_dZ == 0.0);} |
In this case, if our point has coordinates (0.0, 0.0, 0.0), the logical not operator will return true. Otherwise, it will return false. Thus, we can say:
1
2
3
4
5
6
| Point cPoint; // use default contructor to set to (0.0, 0.0, 0.0)if (!cPoint) cout << "cPoint was set at the origin." << endl;else cout << "cPoint was not set at the origin." << endl; |
which produces the result:
0 comments: