C++ Wrapper-Klasse für Iostream, verwenden Sie Stream-Modifizierer wie std :: endl mit Operator <<

Question

Ich schreibe gerade einen Wrapper für eine std::stringstream und ich möchte alle operator<< Anrufe über meine Klasse an die std::stringstream weiterleiten. Dies funktioniert jetzt gut (Danke an diese Frage: wrapper class for STL stream: forward operator<< calls), aber es gibt immer noch ein Problem damit.

Sagen wir, ich habe den folgenden Code:

class StreamWrapper { 
private: 
    std::stringstream buffer; 
public: 
    template<typename T> 
    void write(T &t); 

    template<typename T> 
    friend StreamWrapper& operator<<(StreamWrapper& o, T const& t); 

    // other stuff ... 
}; 


template<typename T> 
StreamWrapper& operator<<(StreamWrapper& o, T const& t) { 
    o.write(t); 
    return o; 
} 

template<typename T> 
void StreamWrapper::write(T& t) { 
    // other stuff ... 

    buffer << t; 

    // other stuff ... 
} 

Wenn ich das jetzt tun:

StreamWrapper wrapper; 
wrapper << "text" << 15 << "stuff"; 

Dies funktioniert gut. Aber wenn ich die Stream-Modifikatoren wie std::endl verwenden möchte, die eine Funktion gemäß http://www.cplusplus.com/reference/ios/endl ist, kompiliere ich einfach nicht.

StreamWrapper wrapper; 
wrapper << "text" << 15 << "stuff" << std::endl; 

Warum? Wie kann ich die Stream-Modifikatoren auch weiterleiten?

Answer 1

Siehe this answer.

werden Sie

wollen

typedef std::ostream& (*STRFUNC)(std::ostream&); 

StreamWrapper& operator<<(STRFUNC func) // as a member, othewise you need the additional StreamWrappe& argument first 
{ 
    this->write(func); 
    return *this; 
} 

Answer 2

Sie scheinen ein bisschen mehr Arbeit zu tun. Ich benutze normalerweise:

class StreamWrapper 
{ 
    // ... 
public: 
    template <typename T> 
    StreamWrapper& operator<<(T const& obj) 
    { 
     // ... 
    } 
}; 

Mit einem modernen Compiler, diese sollte Arbeit für alle konkreten Typen. Das Problem besteht darin, dass Manipulatoren Template-Funktionen sind, , so dass der Compiler keine Vorlage Argument Typ Abzug ausführen kann. Die Lösung ist nicht-Template Überlastungen für die Typen der Manipulatoren zu bieten:

StreamWrapper& operator<<(std::ostream& (*pf)(std::ostream&)) 
{ 
    // For manipulators... 
} 

StreamWrapper& operator<<(std::basic_ios<char>& (*pf)(std::basic_ios<char>&) 
{ 
    // For manipulators... 
} 

Typ Abzug für die Manipulatoren scheitern, aber der Compiler werden diese für die Funktion der Überladungsauflösung aufzunehmen.

(Beachten Sie, dass Sie noch mehr vielleicht brauchen, für Dinge wie std::setw(int).)