Re: Error operator+ function
On Feb 12, 6:07 pm, =D6=F6 Tiib <oot...@hot.ee> wrote:
On Feb 12, 1:10 pm, James Kanze <james.ka...@gmail.com> wrote:
[...]
This way, you get exactly what you want. (Somewhere floating
around I've got a template base class which does this
automatically if you define an A::operator+=(unsigned rhs)
member. Something like:
template< typename DerivedType, typename SecondType >
class MixedArithmeticOperators
{
friend DerivedType operator+(
DerivedType const& lhs,
SecondType const& rhs )
{
DerivedType result(lhs);
result += rhs;
return result;
}
friend DerivedType operator+(
SecondType const& lhs,
DerivedType const& rhs )
{
DerivedType result(rhs);
result += lhs;
return result;
}
};
You'd then just derive from MixedArithmeticOperators<A,
unsigned>.
Seems good, but isn't it simpler to accept parameter by value
if you are otherwise going to copy it anyway? ...
Maybe. If you like revealing implementation details in the
interface:-).
Seriously, in this case, you could argue both ways; the fact
that you copy it here is almost part of the contract (since the
contract says you use the += operator of DerivedType, and that
operator requires a non-const object). On the other hand, why
deviate from the general rule, especially in an inline
function, where it can make no possible difference with any
decent compiler.
(The "general" rule, almost universal in coding guidelines, is
use reference to const for class types, value for all others.
Arguably, this is premature optimization, and the rule should
be: use value, unless the profiler says otherwise. But this
general rule seems ubiquous, and I suspect that without it, the
profiler would say otherwise often enough to be more than a
little bothersome.)
template< typename Derived, typename Other >
class MixedArithmeticOperators
{
friend Derived operator+( Derived lhs
, Other const& rhs )
{
lhs += rhs;
return lhs;
}
friend Derived operator+( Other const& lhs
, Derived rhs )
{
rhs += lhs;
return rhs;
}
};
A third possiblity---one that I've seen more often than the
above, is:
template< typename DerivedType, typename SecondType >
class MixedArithmeticOperators
{
friend DerivedType operator+(
DerivedType const& lhs,
SecondType const& rhs )
{
return DerivedType(lhs) += rhs;
}
friend DerivedType operator+(
SecondType const& lhs,
DerivedType const& rhs )
{
return DerivedType(rhs) += lhs;
}
};
I'll admit that I don't like it too much; I don't like side
effects in a return statement. But it is the most succinct.
(BTW: I rather like your formatting, with the comma at the start
of the line, followed by a space. I've never been able to
convince anyone else to use it, however, and of course, I do
follow the local coding guidelines, always. Have you ever
succeeded in getting this style into the coding guidelines?)
--
James Kanze