C++ Primer Plus

    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;

}

std::ostream & operator<<(std::ostream & os, const Time & t)

{

    os << t.hours << " hours, " << t.minutes << " minutes";

    return os;

}

Listing 11.12 shows a sample program. Technically, usetime3.cpp doesn’t have to include iostream because mytime3.h already includes that file. However, as a user of the Time class, you don’t necessarily know which files are included in the class code, so you would take the responsibility of declaring those header files that you know your part of the code needs.

Listing 11.12. usetime3.cpp

//usetime3.cpp -- using the fourth draft of the Time class

// compile usetime3.cpp and mytime3.cpp together

#include

#include "mytime3.h"

int main()

{

   using std::cout;

   using std::endl;

   Time aida(3, 35);

   Time tosca(2, 48);

   Time temp;

   cout << "Aida and Tosca:\n";

   cout << aida<<"; " << tosca << endl;

   temp = aida + tosca;     // operator+()

   cout << "Aida + Tosca: " << temp << endl;

   temp = aida* 1.17;  // member operator*()

   cout << "Aida * 1.17: " << temp << endl;

   cout << "10.0 * Tosca: " << 10.0 * tosca << endl;

   return 0;

}

Here is the output of the program in Listings 11.10, 11.11, and 11.12:

Aida and Tosca:

3 hours, 35 minutes; 2 hours, 48 minutes

Aida + Tosca: 6 hours, 23 minutes

Aida * 1.17: 4 hours, 11 minutes

10.0 * Tosca: 28 hours, 0 minutes

Overloaded Operators: Member Versus Nonmember Functions

For many operators, you have a choice between using member functions or nonmember functions to implement operator overloading. Typically, the nonmember version is a friend function so that it can directly access the private data for a class. For example, consider the addition operator for the Time class. It has this prototype in the Time class declaration:

Time operator+(const Time & t) const; // member version

Instead, the class could use the following prototype:

// nonmember version

friend Time operator+(const Time & t1, const Time & t2);

The addition operator requires two operands. For the member function version, one is passed implicitly via the this pointer and the second is passed explicitly as a function argument. For the friend version, both are passed as arguments.

Note

A nonmember version of an overloaded operator function requires as many formal parameters as the operator has operands. A member version of the same operator requires one fewer parameter because one operand is passed implicitly as the invoking object.

Either of these two prototypes matches the expression T2 + T3, where T2 and T3 are type Time objects. That is, the compiler can convert the statement

T1 = T2 + T3;

to either of the following:

T1 = T2.operator+(T3);    // member function

T1 = operator+(T2, T3);   // nonmember function

Keep in mind that you must choose one or the other form when defining a given operator, but not both. Because both forms match the same expression, defining both forms is an ambiguity error, leading to a compilation error.

Which form, then, is it best to use? For some operators, as mentioned earlier, the member function is the only valid choice. Otherwise, it often doesn’t make much difference. Sometimes, depending on the class design, the nonmember version may have an advantage, particularly if you have defined type conversions for the class. The section “Conversions and Friends,” near the end of this chapter, discusses this situation further.

More Overloading: A Vector Class