On Sep 8, 3:26 pm, puzzlecracker <ironsel2...@gmail.comwrote:
Quote:
I usually provide a normal,
Quote:
Quote:
named member function print, and derive from a template
class using the Barton and Nackman trick to provide the
operators, but
Quote:
Please elaborate on this:the Barton and Nackman trick
It's pretty straight-forward, really. The base class contains
an inline definition of the operator---declared as friend,
because that's the only way you can provide an implementation
inline in a class for a non-member function. It's not really
something fundamentally necessary for operator<< and >>; it's
more useful for things like an operator+ (based on +=), etc.
Anyway, you define a base class template along the lines of:
template< typename T >
class Operators
{
friend T operator+( T const& lhs, T const& rhs )
{
T result( lhs ) ;
result += rhs ;
return result ;
}
// ...
friend std::ostream& operator<<(
std::ostream const& dest,
T const& obj )
{
obj.print( dest ) ;
return dest ;
}
// ...
} ;
Then, whenever you need the operators, just derive from the
class:
class Whatever : public Operators< Whatever >
{
public :
// ...
Whatever& operator+=( Whatever const& other ) ;
// ...
void print( std::ostream& dest ) const ;
// ...
} ;
I actually have several different template base classes for
this: ArithmeticOperators, MixedArithmeticOperators (with two
template parameters, for mixed type arithmetic),
STLIteratorOpertors (converts a "normal" iterator into STL), and
IOStreamOperators.
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
