krach mit newline

hallo, habe diese klasse gefunden

class a2str 
{ 
	stringstream ss; 
	public: 
		template<typename T> 
		a2str& operator<<(T const& x) { ss<<x; return *this; } 
		operator string() const { return ss.str(); } 
};

und würd auch gern endl benutzen, gibt aber leider ne seite voller fehler:

error C2914: "a2str::operator <<": template-Argument kann nicht hergeleitet werden, da das Funktionsargument mehrdeutig ist.
error C2784: "std::basic_ostream<_Elem,_Traits> &std::operator <<(std::basic_ostream<_Elem,_Traits> &,const std::basic_string<_Elem,_Traits,_Alloc> &)": template-Argument für "std::basic_ostream<_Elem,_Traits> &" konnte nicht von "a2str" hergeleitet werden.
...
usw.
...

beim aufruf:

string s = a2str() << "I want newline" << endl;

ohne endl gehts, aber ich würds gern benutzen, geht das irgendwie?

Badestrand

Fehlt vielleicht das richtige Include (frag mich nicht, welches, evtl iostream)?

camper

endl ist ein Funktionstemplate, folglich

string sss = a2str() << "I want newline" << endl<char, char_traits<char> >;

oder

string ss = a2str() << "I want newline" << static_cast<basic_ostream<char, char_traits<char> >&(*)(basic_ostream<char, char_traits<char> >&)>(endl);

oder einfach noch eine entsprechende Überladung in a2str hinzufügen

class a2str
{
...
    a2str& operator<<(basic_ostream<char, char_traits<char> >& pf(basic_ostream<char, char_traits<char> >&)) { return pf(ss), *this; }

krass
funktioniert,
vielen dank!

Th69

endl macht bei dieser Helper-Klasse ja eigentlich keinen Sinn, da das 'flushen' für den internen 'stringstream' unnötig ist.
Stattdessen reicht doch ein einfacher Zeilenumbruch: '\n'

Für andere Stream-Manipulatoren (z.B. hex) ist die zusätzliche Überladung jedoch sinnvoll.

unskilled

Seit wann sollte ein streaming op am ende noch ein newline hängen? halt ich für falsch

kann man die klasse auch für den wstring typen benutzen?
hab so einiges schon probiert, aber ich kriegs nicht hin!

camper

template <typename charT, typename traitsT = std::char_traits<charT>, typename Allocator = std::allocator<charT> >
class basic_a2str
{
    std::basic_ostringstream<charT, traitsT, Allocator> ss;
    typedef std::basic_ostream<charT, traitsT>& manip(basic_ostream<charT, traitsT>&);
public:
    operator std::basic_string<charT, traitsT, Allocator>() const { return ss.str(); }
    template<typename T>
    basic_a2str& operator<<(const T& x) { ss << x; return *this; }
    basic_a2str& operator<<(manip pf) { ss << pf; return *this; }	
};
typedef basic_a2str<char> a2str;
typedef basic_a2str<wchar_t> a2wstr;

hhmmm...für den aufruf muss man aber die spitzen klammern benutzen, ne?
mit überladen geht das wohl nicht irgendwie ...

Th69

Nein, braucht man eigentlich nicht. Wie rufst du es denn auf? Beachte daß wide-char-Literale als L"..." codiert werden müssen.