C++ Primer Plus

More Overloaded Operators

Some other operations make sense for the Time class. For example, you might want to subtract one time from another or multiply a time by a factor. This suggests overloading the subtraction and multiplication operators. The technique is the same as for the addition operator: you create operator-() and operator*() methods. That is, you add the following prototypes to the class declaration:

Time operator-(const Time & t) const;

Time operator*(double n) const;

Listing 11.7 shows the new header file.

Listing 11.7. mytime2.h

// mytime2.h -- Time class after operator overloading

#ifndef MYTIME2_H_

#define MYTIME2_H_

class Time

{

private:

    int hours;

    int minutes;

public:

    Time();

    Time(int h, int m = 0);

    void AddMin(int m);

    void AddHr(int h);

    void Reset(int h = 0, int m = 0);

    Time operator+(const Time & t) const;

    Time operator-(const Time & t) const;

    Time operator*(double n) const;

    void Show() const;

};

#endif

Then you add definitions for the new methods to the implementation file, as shown in Listing 11.8.

Listing 11.8. mytime2.cpp

// mytime2.cpp  -- implementing Time methods

#include

#include "mytime2.h"

Time::Time()

{

    hours = minutes = 0;

}

Time::Time(int h, int m )

{

    hours = h;

    minutes = m;

}

void Time::AddMin(int m)

{

    minutes += m;

    hours += minutes / 60;

    minutes %= 60;

}

void Time::AddHr(int h)

{

    hours += h;

}

void Time::Reset(int h, int m)

{

    hours = h;

    minutes = m;

}

Time Time::operator+(const Time & t) const

{

    Time sum;

    sum.minutes = minutes + t.minutes;

    sum.hours = hours + t.hours + sum.minutes / 60;

    sum.minutes %= 60;

    return sum;

}

Time Time::operator-(const Time & t) const

{

    Time diff;

    int tot1, tot2;

    tot1 = t.minutes + 60 * t.hours;

    tot2 = minutes + 60 * hours;

    diff.minutes = (tot2 - tot1) % 60;

    diff.hours = (tot2 - tot1) / 60;

    return diff;

}

Time Time::operator*(double mult) const

{

    Time result;

    long totalminutes = hours * mult * 60 + minutes * mult;

    result.hours = totalminutes / 60;

    result.minutes = totalminutes % 60;

    return result;

}

void Time::Show() const

{

    std::cout << hours << " hours, " << minutes << " minutes";

}

With these changes made, you can test the new definitions with the code shown in Listing 11.9.

Listing 11.9. usetime2.cpp

// usetime2.cpp -- using the third draft of the Time class

// compile usetime2.cpp and mytime2.cpp together

#include

#include "mytime2.h"

int main()

{

    using std::cout;

    using std::endl;

    Time weeding(4, 35);

    Time waxing(2, 47);

    Time total;

    Time diff;

    Time adjusted;

    cout << "weeding time = ";

    weeding.Show();

    cout << endl;

    cout << "waxing time = ";

    waxing.Show();

    cout << endl;

    cout << "total work time = ";

    total = weeding + waxing;   // use operator+()

    total.Show();

    cout << endl;

    diff = weeding - waxing;    // use operator-()

    cout << "weeding time - waxing time = ";

    diff.Show();

    cout << endl;

    adjusted = total * 1.5;      // use operator+()

    cout << "adjusted work time = ";

    adjusted.Show();

    cout << endl;

    return 0;

}

Here is the output of the program in Listings 11.7, 11.8, and 11.9:

weeding time = 4 hours, 35 minutes

waxing time = 2 hours, 47 minutes

total work time = 7 hours, 22 minutes

weeding time - waxing time = 1 hours, 48 minutes

adjusted work time = 11 hours, 3 minutes

Introducing Friends

As you’ve seen, C++ controls access to the private portions of a class object. Usually, public class methods serve as the only access, but sometimes this restriction is too rigid to fit particular programming problems. In such cases, C++ provides another form of access: the friend. Friends come in three varieties:

• Friend functions

• Friend classes

• Friend member functions

By making a function a friend to a class, you allow the function the same access privileges that a member function of the class has. We’ll look into friend functions now, leaving the other two varieties to Chapter 15, “Friends, Exceptions, and More.”

Before seeing how to make friends, let’s look into why they might be needed. Often, overloading a binary operator (that is, an operator with two arguments) for a class generates a need for friends. Multiplying a Time object by a real number provides just such a situation, so let’s study that case.

In the previous Time class example, the overloaded multiplication operator is different from the other two overloaded operators in that it combines two different types. That is, the addition and subtraction operators each combine two Time values, but the multiplication operator combines a Time value with a double value. This restricts how the operator can be used. Remember, the left operand is the invoking object. That is,

A = B * 2.75;

translates to the following member function call:

A = B.operator*(2.75);

But what about the following statement?

A = 2.75 * B;     // cannot correspond to a member function