Re: concrete example on "inheriting" from ostream
AlfC wrote:
This message is actually a request for small working example
or at least a clear explanation on how to build a class that
behaves almost like a std::ostream except that some types are
printed with a different format.
Such a thing normally doesn't exist. The underlying abstraction
of std::ostream is texual formatting. If you want that
abstraction, you use ostream (or a class derived from it); if
you don't (e.g. you want some particular binary format, like
XDR), you don't use ostream.
I had been thinking that some types can be printed to streams and
change the format according to the context, where the context is
specified by the type of stream itself. in other words I have the idea
of creating different streams for printing data in different format.
Nothing new there. That's what manipulators are for. Look at
how doubles are output in different formats, for example,
depending on the context (i.e. which manipulator was used
previously).
If the set of pre-defined flags and values (e.g. width,
precision and fill) aren't enough for you (often the case for a
user defined type), check out ios::xalloc(), ios::iword() and
ios::pword().
for a simplified example, supose I want to print a complex number in
two different formats although integer types are always written in a
default cannonical way.
A perfect example of a case where a manipulator would be
appropriate. Another solution is to use the decorator pattern,
with the actual formatting being done by the decorator.
std::ofstream ofs("ofs.txt");
ofs<<std::complex<double>(3,4)<<" "<<9<<std::endl;
should print the expected "(3,4) 9" to a file
however I would like to have a different stream that works in another
format:
custom_ofstream cofs("cofs.txt")
cofs<<std::complex<double>(3,4)<<" "<<9<<std::endl;
should print "3+i4 9"
That sounds more like a case for a manipulator (or a global
function setting formatting state in the ostream class), i.e.:
std::cout << std::complex< double >( 3, 4 ) << " " << 9 <<
std::endl ;
std::cout << expressionFormat ;
std::cout << std::complex< double >( 3, 4 ) << " " << 9 <<
std::endl ;
std::cout << standardFormat ;
std::cout << std::complex< double >( 3, 4 ) << " " << 9 <<
std::endl ;
This example would output:
(3,4) 9
3+i4 9
(3,4) 9
In this case, the format is sticky, so it will last until
replaced by another format. It is also fairly direct to ensure
that it returns to the default at the end of the expression.
(The decorator technique is good for outputting a single value
only with another format.)
Looking in previous topics in the group I found that doing something
like this requires a more involved approach consisting in first
creating a class "custom_streambuf" that is derived from std::streambuf
and then creating the "custom_ofstream" class as privatelly derived
from custom_streambuf and publicly derived from ofstream. This is
described here
http://www.angelikalanger.com/Articles/C++Report/IOStreamsDerivation/IOStreamsDerivation.html
That addresses an entirely different problem: defining an
ostream which writes to a different type of destination. (I
doubt that there is a Unix C++'er in existance who doesn't have
an opipestream, or something similar, in his tool kit.)
However I didn't manage to compile that "schematic" code or even better
to reach the point were I define the new behavior of "cofs<<??? " for
certain types.
That'a because you're not supposed to. The ostream class uses
the strategy pattern for its data sink. And the only thing
derivation does is to provide convenience creation of the new
delegate (the streambuf).
note that I would like "cofs<<???" to work for buildin types (e.g. int,
double), standard classes whose source code can not be modified (e.g.
std::complex<double>), and user class whose source code can be modified
(e.g. class Employee).
It's possible to use an ostream wrapper for this, with a
template << which forewards to the << of the ostream, and
explicit specialization for the types you want to handle
differently, but off hand, I can't imagine a problem for which
this would be the appropriate solution.
This question (or similar questions) had been around the group many
times however I didn't find a working code that reaches the point where
"friend operator<<(custom_ostream& , type const&)" or eventually member
"custom_ostream::operator<<(type const&)" is defined. Does any one have
a complete small working example of how to define output streams that
behaves much like a standard output stream except than *some* specific
types are printed in a different format?
Probably not, because that's not how iostreams work.
I particular I am interested in the approach that uses "virtual
private" inheritance (which sounds very professional).
No matter how it sounds, I can't imagine any case where you
would use virtual private inheritance with ostream. (If this is
homework, and the instructor has asked for some such, I'd
suggest changing schools.)
Note that I still didn't ask yet about adding (or reusing standard)
manipulators, which is something that I will eventually need. Probably
an elegant solution will keep the old manipulators available for the
new custom output streams.
No. An elegant solution will use new manipulators. Which, of
course, doesn't prevent the old ones from still being used. In
fact, you very definitly will want to take setw (or more
correctly, ios::width(), which is what setw calls) into account.
--
James Kanze Gabi Software email: kanze.james@neuf.fr
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
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]