Classe wrapper C++ per iostream, utilizzare modificatori di flusso come std :: endl con operatore <<

Question

Attualmente sto scrivendo un wrapper per un std::stringstream e voglio inoltrare tutte le chiamate operator<< attraverso la mia classe allo std::stringstream. Questo funziona bene ora (grazie a questa domanda: wrapper class for STL stream: forward operator<< calls), ma c'è ancora un problema con esso.

Diciamo che ho il seguente codice:

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 ... 
} 

Se ora faccio questo:

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

Questo funziona bene. Ma se voglio usare i modificatori di flusso come std::endl, che è una funzione in base a http://www.cplusplus.com/reference/ios/endl, semplicemente non compilo.

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

Perché? Come posso inoltrare anche i modificatori di flusso?

Answer 1

Vedere this answer.

Vorrete

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

Sembra che tu stia facendo un po 'di lavoro extra. Io di solito uso:

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

con un compilatore moderno, questo dovrebbe lavoro per tutti i tipi concreti . Il problema è che i manipolatori sono funzioni modello, , quindi il compilatore non è in grado di eseguire la deduzione del tipo di argomento modello . La soluzione è quella di fornire sovraccarichi non template per i tipi di manipolatori:

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

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

Tipo deduzione fallirà per i manipolatori, ma il compilatore prenderà questi per la risoluzione funzione di sovraccarico.

(Si noti che potrebbe essere necessario ancora di più, per cose come std::setw(int).)