Overloading unary operators +, -, and !

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:

01	class Cents

02

{

03

private:

04	int m_nCents;

05

06

public:

07	Cents(int nCents) { m_nCents = nCents; }

08

09	// Overload -cCents

10	friend Cents operator-(const Cents &cCents);

11

};

12

13	// note: this function is not a member function!

14	Cents operator-(const Cents &cCents)

15

{

16	return Cents(-cCents.m_nCents);

17

}

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

if (!nX)

2	// do something

Similarly, we can overload the ! operator to work similarly for a user-defined class:

01	class Point

02

{

03

private:

04	double m_dX, m_dY, m_dZ;

05

06

public:

07	Point(double dX=0.0, double dY=0.0, double dZ=0.0)

08

{

09	m_dX = dX;

10	m_dY = dY;

11	m_dZ = dZ;

12

}

13

14	// Convert a Point into it's negative equivalent

15	friend Point operator- (const Point &cPoint);

16

17	// Return true if the point is set at the origin

18	friend bool operator! (const Point &cPoint);

19

20	double GetX() { return m_dX; }

21	double GetY() { return m_dY; }

22	double GetZ() { return m_dZ; }

23

};

24

25	// Convert a Point into it's negative equivalent

26	Point operator- (const Point &cPoint)

27

{

28	return Point(-cPoint.m_dX, -cPoint.m_dY, -cPoint.m_dZ);

29

}

30

31	// Return true if the point is set at the origin

32	bool operator! (const Point &cPoint)

33

{

34	return (cPoint.m_dX == 0.0 &&

35	cPoint.m_dY == 0.0 &&

36	cPoint.m_dZ == 0.0);

37

}

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	Point cPoint; // use default contructor to set to (0.0, 0.0, 0.0)

2

3	if (!cPoint)

4	cout << "cPoint was set at the origin." << endl;

5

else

6	cout << "cPoint was not set at the origin." << endl;

which produces the result:

cPoint was set at the origin.