C++ Primer Plus

total = coding + fixing;              // operator notation

Either notation invokes the operator+() method. Note that with the operator notation, the object to the left of the operator (coding, in this case) is the invoking object, and the object to the right (fixing, in this case) is the one passed as an argument. Listing 11.6 illustrates this point.

Listing 11.6. usetime1.cpp

// usetime1.cpp -- using the second draft of the Time class

// compile usetime1.cpp and mytime1.cpp together

#include

#include "mytime1.h"

int main()

{

    using std::cout;

    using std::endl;

    Time planning;

    Time coding(2, 40);

    Time fixing(5, 55);

    Time total;

    cout << "planning time = ";

    planning.Show();

    cout << endl;

    cout << "coding time = ";

    coding.Show();

    cout << endl;

    cout << "fixing time = ";

    fixing.Show();

    cout << endl;

    total = coding + fixing;

    // operator notation

    cout << "coding + fixing = ";

    total.Show();

    cout << endl;

    Time morefixing(3, 28);

    cout << "more fixing time = ";

    morefixing.Show();

    cout << endl;

    total = morefixing.operator+(total);

    // function notation

    cout << "morefixing.operator+(total) = ";

    total.Show();

    cout << endl;

    return 0;

}

Here is the output of the program in Listings 11.4, 11.5, and 11.6:

planning time = 0 hours, 0 minutes

coding time = 2 hours, 40 minutes

fixing time = 5 hours, 55 minutes

coding + fixing = 8 hours, 35 minutes

more fixing time = 3 hours, 28 minutes

morefixing.operator+(total) = 12 hours, 3 minutes

In short, the name of the operator+() function allows it to be invoked by using either function notation or operator notation. The compiler uses the operand types to figure out what to do:

int a, b, c;

Time A, B, C;

c = a + b;      // use int addition

C = A + B;      // use addition as defined for Time objects

Can you add more than two objects? For example, if t1, t2, t3, and t4 are all Time objects, can you do the following?

t4 = t1 + t2 + t3;                     // valid?

The way to answer this is to consider how the statement gets translated into function calls. Because addition is a left-to-right operator, the statement is first translated to this:

t4 = t1.operator+(t2 + t3);            // valid?

Then the function argument is itself translated to a function call, giving the following:

t4 = t1.operator+(t2.operator+(t3));   // valid? YES

Is this valid? Yes, it is. The function call t2.operator+(t3) returns a Time object that represents the sum of t2 and t3. This object then becomes the object of the t1.operator+() function call, and that call returns the sum of t1 and the Time object that represents the sum of t2 and t3. In short, the final return value is the sum of t1, t2, and t3, just as desired.

Overloading Restrictions

Most C++ operators (see Table 11.1) can be overloaded in the manner described in the preceding section. Overloaded operators (with some exceptions) don’t necessarily have to be member functions. However, at least one of the operands has to be a user-defined type. Let’s take a closer look at the limits C++ imposes on user-defined operator overloading:

• The overloaded operator must have at least one operand that is a user-defined type. This prevents you from overloading operators for the standard types. Thus, you can’t redefine the minus operator (-) so that it yields the sum of two double values instead of their difference. This restriction preserves program sanity, although it may hinder creative accounting.

• You can’t use an operator in a manner that violates the syntax rules for the original operator. For example, you can’t overload the modulus operator (%) so that it can be used with a single operand:

int x;

Time shiva;

% x;       // invalid for modulus operator

% shiva;   // invalid for overloaded operator

Similarly, you can’t alter operator precedence. So if you overload the addition operator to let you add two classes, the new operator has the same precedence as ordinary addition.

• You can’t create new operator symbols. For example, you can’t define an operator**() function to denote exponentiation.

• You cannot overload the following operators:

This still leaves all the operators in Table 11.1 available for overloading.

• Most of the operators in Table 11.1 can be overloaded by using either member or nonmember functions. However, you can use only member functions to overload the following operators:

Table 11.1. Operators That Can Be Overloaded

Note

This chapter does not cover every operator mentioned in the list of restrictions or in Table 11.1. However, Appendix E, “Other Operators,” summarizes the operators that are not covered in the main body of this text.

In addition to these formal restrictions, you should use sensible restraint in overloading operators. For example, you shouldn’t overload the * operator so that it swaps the data members of two Time objects. Nothing in the notation would suggest what the operator did, so it would be better to define a class method with an explanatory name such as Swap().