could you tell me why there is a friend for the << operator?

friend ostream& operator<< (ostream &out, const Cents &cCents) 

{ 

out << cCents.m_nCents << " cents "; 

return out; 

} 

Thanks

As to why your example didn’t work, let’s start with a simpler one. Consider the following statement:

std::cout << Cents(5) << std::endl;

Would you expect this to work if operator<< didn’t take a const Cents reference?

The answer should be no. Cents(5) is an rvalue, and does not have it’s own address. Thus, you can’t set a reference to it.

Because Average() is returning a Cents by value, it’s falling into the same trap. It’s the exact same reason the following doesn’t work:

void foo(int &x)
{
}

foo(5); // doesn't work

However, if you make the reference const, then you CAN pass in literals and temporaries.

void foo(const int &x)
{
}

foo(5); // works

and similarly, the return-by-value Cents from Average works as well.

As to your second question, you can’t return *this from Average because it’s not a member function.

Consider the logical meaning of the following statment:

if (c1 > c2)

if the > operator returns a bool here, then c1 > c2 returns a bool here and this makes sense. But if it returns a Cents instead, what does that mean logically?

excellent tutorial! I found a little typo though. The
Last return statement in the last block of code in the
“Operators, function calls, and function templates” is

return (c1.m_nCents > c2.m_nCents) ? true : false;

but it should be

return (c1.m_nCents > c2.m_nCents) ? c1 : c2;

Also, the return type shouldn’t be bool, but Cents.
Otherwise it does not fit the max-template. Right?

Thanks!

Andreas

If I use

friend std::ostream& operator<< (std::ostream &out, Cents &cCents);
{
out << cCents.m_nCents << " cents ";
return out;
}

as my << overide definition within the Cents class, then the line

std::cout << Average(cArray,4) << std::endl;

in the main function produces an error in my compiler (see below), which I
think is related to the chaining of the << operator.

error: no match for ‘operator<<’ in ‘std::cout << Average [with T = Cents](((Cents)(& cArray)), 4)’

If the Average function returned a *this pointer I think this would solve
the problem (alternatively, I can introduce a dummy Cents variable to
store the result of Average, and std::cout that). However, another way to
resolve this problems is to rewrite the << override function with a const
input for Cents, like so:

friend std::ostream& operator<< (std::ostream &out, const Cents &cCents);

Now the line

std::cout << Average(cArray,4) << std::endl;

compiles without a problem! Can you help me understand why the addtion of
the const keyword to the input resolves the problem of chaining the output
of the Average function for Cents? Also, would it be possible to modify the
template Average function so that for classes it returned a *this pointer
rather than a value? I suspect not as the function is outside of the Cents
class, but would be interested to know. This appears to be the same problem
as Ben (post #1) had.

Thanks,

Mark

P.S. Fantastic tutorial by the way!

Another small typo, just after the introduction of the Cents class the text mentions the “height” class.