ptg7544714 nience functions. This is another feature classes can’t offer, because
class definitions are closed to extension by clients. Sure, clients can derive new classes, but derived classes have no access to encapsu- lated (i.e., private) members in the base class, so such “extended func- tionality” has second-class status. Besides, as Item 7 explains, not all classes are designed to be base classes.
Things to Remember
✦Prefer non-member non-friend functions to member functions. Do- ing so increases encapsulation, packaging flexibility, and functional extensibility.
Item 24: Declare non-member functions when type
ptg7544714 contrary to object-oriented principles, but let’s set that aside and
investigate the idea of making operator* a member function of Rational: class Rational {
public:
...
const Rational operator*(const Rational& rhs) const;
};
(If you’re unsure why this function is declared the way it is — return- ing a const by-value result, but taking a reference-to-const as its argu- ment — consult Items 3, 20, and 21.)
This design lets you multiply rationals with the greatest of ease:
Rational oneEighth(1, 8);
Rational oneHalf(1, 2);
Rational result = oneHalf * oneEighth; // fine
result = result * oneEighth; // fine
But you’re not satisfied. You’d also like to support mixed-mode opera- tions, where Rationals can be multiplied with, for example, ints. After all, few things are as natural as multiplying two numbers together, even if they happen to be different types of numbers.
When you try to do mixed-mode arithmetic, however, you find that it works only half the time:
result = oneHalf * 2; // fine
result = 2 * oneHalf; // error!
This is a bad omen. Multiplication is supposed to be commutative, remember?
The source of the problem becomes apparent when you rewrite the last two examples in their equivalent functional form:
result = oneHalf.operator*(2); // fine result = 2.operator*(oneHalf); // error!
The object oneHalf is an instance of a class that contains an operator*, so compilers call that function. However, the integer 2 has no associ- ated class, hence no operator* member function. Compilers will also look for non-member operator*s (i.e., ones at namespace or global scope) that can be called like this:
result = operator*(2, oneHalf); // error!
But in this example, there is no non-member operator* taking an int and a Rational, so the search fails.
ptg7544714 Look again at the call that succeeds. You’ll see that its second param-
eter is the integer 2, yet Rational::operator* takes a Rational object as its argument. What’s going on here? Why does 2 work in one position and not in the other?
What’s going on is implicit type conversion. Compilers know you’re passing an int and that the function requires a Rational, but they also know they can conjure up a suitable Rational by calling the Rational constructor with the int you provided, so that’s what they do. That is, they treat the call as if it had been written more or less like this:
const Rational temp(2); // create a temporary // Rational object from 2
result = oneHalf * temp; // same as oneHalf.operator*(temp);
Of course, compilers do this only because a non-explicit constructor is involved. If Rational’s constructor were explicit, neither of these state- ments would compile:
result = oneHalf * 2; // error! (with explicit ctor);
// can’t convert 2 to Rational result = 2 * oneHalf; // same error, same problem
That would fail to support mixed-mode arithmetic, but at least the behavior of the two statements would be consistent.
Your goal, however, is both consistency and support for mixed-mode arithmetic, i.e., a design where both of the above statements will com- pile. That brings us back to these two statements and why, even when Rational’s constructor is not explicit, one compiles and one does not:
result = oneHalf * 2; // fine (with non-explicit ctor) result = 2 * oneHalf; // error! (even with non-explicit ctor) It turns out that parameters are eligible for implicit type conversion only if they are listed in the parameter list. The implicit parameter cor- responding to the object on which the member function is invoked — the one this points to — is never eligible for implicit conversions.
That’s why the first call compiles and the second one does not. The first case involves a parameter listed in the parameter list, but the second one doesn’t.
You’d still like to support mixed-mode arithmetic, however, and the way to do it is by now perhaps clear: make operator* a non-member function, thus allowing compilers to perform implicit type conversions on all arguments:
ptg7544714 class Rational {
... // contains no operator*
};
const Rational operator*(const Rational& lhs, // now a non-member const Rational& rhs) // function
{
return Rational(lhs.numerator() * rhs.numerator(), lhs.denominator() * rhs.denominator());
}
Rational oneFourth(1, 4);
Rational result;
result = oneFourth * 2; // fine
result = 2 * oneFourth; // hooray, it works!
This is certainly a happy ending to the tale, but there is a nagging worry. Should operator* be made a friend of the Rational class?
In this case, the answer is no, because operator* can be implemented entirely in terms of Rational’s public interface. The code above shows one way to do it. That leads to an important observation: the opposite of a member function is a non-member function, not a friend function.
Too many C++ programmers assume that if a function is related to a class and should not be a member (due, for example, to a need for type conversions on all arguments), it should be a friend. This exam- ple demonstrates that such reasoning is flawed. Whenever you can avoid friend functions, you should, because, much as in real life, friends are often more trouble than they’re worth. Sometimes friend- ship is warranted, of course, but the fact remains that just because a function shouldn’t be a member doesn’t automatically mean it should be a friend.
This Item contains the truth and nothing but the truth, but it’s not the whole truth. When you cross the line from Object-Oriented C++
into Template C++ (see Item 1) and make Rational a class template instead of a class, there are new issues to consider, new ways to resolve them, and some surprising design implications. Such issues, resolutions, and implications are the topic of Item 46.
Things to Remember
✦If you need type conversions on all parameters to a function (includ- ing the one that would otherwise be pointed to by the this pointer), the function must be a non-member.
ptg7544714