Re: operator << for ostringstream returning ostream is unintuitive
On 19 Nov., 21:39, Patrik Kahari <patrik.kah...@googlemail.com> wrote:
If I understand you correctly. You are saying that its a bad idea for
operator<< to in gerneral be assumed/required to return the type of
its first argument because it would make it very troublesome for user
who wanted to define operator<< for their user type, as they would
have to define the operator<< for each specific ostream type, instead
of just once for the base ostream type.
You understand me correctly, but please let my
opinion regarding this issue be restricted to
the standard IO classes and similar designs.
You got a point. But could this not be solved simply with a more
general template type than ostream for the user defined operator<< ?
Something like:
#include <sstream>
void libFunc(std::ostringstream& msg);
//ostream specific operator<< wich will return base ostream type for
derived ostreams
struct UserType1{};
template<typename charT, typename traits>
std::basic_ostream<charT,traits>& operator<<
(std::basic_ostream<charT,traits>&, const UserType1&);
//More general operator<< that simply returns first argument type
struct UserType2{};
template <typename OutputStream>
OutputStream& operator<< (OutputStream& os, const UserType2& mt);
int main(void) {
UserType1 ut1;
std::ostringstream() << ut1; //OK
libFunc(std::ostringstream() << ut1); //ERROR
(std::ostringstream() << ut1).str(); //ERROR
UserType2 ut2;
std::ostringstream() << ut2; //OK
libFunc(std::ostringstream() << ut2); //OK
(std::ostringstream() << ut2).str(); //OK
}
That would definitively be possible [today
we would probably provide a concept OutputStreamee
;-) for it instead of an unrestricted function
template overload of operator<<]. The usage of such
an unrestricted template is dangerous, because
the role of the arguments and the results of
the IO extractors and inserters strongly deviate
from the arithmetic shift operators << and >>.
This would easily cause ambiguities in situations
where different overloads are visible and could
also lead to well-formed code with surprising effects.
We have to consider the design history of C++'s
IO classes regarding the status quo. The pre
standard IO library did not use templates but
runtime polymorphism. Partial "templatization"
was added later, but switching back to pure
compile-time polymorphism would have had damaged
the basic ideas behind it.
- Daniel Kr?gler
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]