Vermeiden Sie das Kopieren von String aus ostringstream

Question

Ich habe einen Namen std::string, die ich mit Daten über eine std::ostream Schnittstelle ausfüllen und eine Zeichenfolge Kopie vermeiden möchte.
Eine Möglichkeit, es zu tun, die eine Kopie mit sich bringt, dies zu tun:

bool f(std::string& out) 
{ 
    std::ostringstream ostr; 
    fillWithData(ostr); 
    out = ostr.str(); // 2 copies here 
    return true; 
} 

ich das Ergebnis durch out und kann nicht Rückkehrostr.str() übergeben müssen.
Ich möchte die Kopien in out = ostr.str(); vermeiden, da diese Zeichenfolge sehr groß sein kann.

Gibt es einen Weg, vielleicht mit rdbuf() s, um den std::ostream Puffer direkt an out zu binden?

Um zu klären, ich Interesse an dem Auto-Erweiterung Verhalten von std::string und std::ostream so bin , dass der Anrufer nicht über die Größe vor dem Aufruf kennen.

UPDATE: Ich habe erkannt, dass die harmlos Linie out = ostr.str(); wahrscheinlich Kopien nach sich ziehen wird:

1. Die erste von der str() Anruf
2. Die anderen von der std::string Zuweisungsoperator.

Answer 1

Ihre eigenen Stream schreiben:

#include <ostream> 

template <typename Char, typename Traits = std::char_traits<Char>> 
class BasicStringOutputBuffer : public std::basic_streambuf<Char, Traits> 
{ 
    // Types 
    // ===== 

    private: 
    typedef std::basic_streambuf<Char, Traits> Base; 

    public: 
    typedef typename Base::char_type char_type; 
    typedef typename Base::int_type int_type; 
    typedef typename Base::pos_type pos_type; 
    typedef typename Base::off_type off_type; 
    typedef typename Base::traits_type traits_type; 

    typedef typename std::basic_string<char_type> string_type; 

    // Element Access 
    // ============== 

    public: 
    const string_type& str() const { return m_str; } 
    string_type& str() { return m_str; } 

    // Stream Buffer Interface 
    // ======================= 

    protected: 
    virtual std::streamsize xsputn(const char_type* s, std::streamsize n); 
    virtual int_type overflow(int_type); 

    // Utilities 
    // ========= 

    protected: 
    int_type eof() { return traits_type::eof(); } 
    bool is_eof(int_type ch) { return ch == eof(); } 

    private: 
    string_type m_str; 
}; 

// Put Area 
// ======== 

template < typename Char, typename Traits> 
std::streamsize 
BasicStringOutputBuffer<Char, Traits>::xsputn(const char_type* s, std::streamsize n) { 
    m_str.append(s, n); 
    return n; 
} 

template < typename Char, typename Traits> 
typename BasicStringOutputBuffer<Char, Traits>::int_type 
BasicStringOutputBuffer<Char, Traits>::overflow(int_type ch) 
{ 
    if(is_eof(ch)) return eof(); 
    else { 
     char_type c = traits_type::to_char_type(ch); 
     return xsputn(&c, 1); 
    } 
} 


// BasicStringOutputStream 
//============================================================================= 

template < typename Char, typename Traits = std::char_traits<Char> > 
class BasicStringOutputStream : public std::basic_ostream<Char, Traits> 
{ 
    protected: 
    typedef std::basic_ostream<Char, Traits> Base; 

    public: 
    typedef typename Base::char_type char_type; 
    typedef typename Base::int_type int_type; 
    typedef typename Base::pos_type pos_type; 
    typedef typename Base::off_type off_type; 
    typedef typename Base::traits_type traits_type; 
    typedef typename BasicStringOutputBuffer<Char, Traits>::string_type string_type; 

    // Construction 
    // ============ 

    public: 
    BasicStringOutputStream() 
    : Base(&m_buf) 
    {} 

    // Element Access 
    // ============== 

    public: 
    const string_type& str() const { return m_buf.str(); } 
    string_type& str() { return m_buf.str(); } 

    private: 
    BasicStringOutputBuffer<Char, Traits> m_buf; 
}; 

typedef BasicStringOutputStream<char> StringOutputStream; 


// Test 
// ==== 

#include <iostream> 

int main() { 
    StringOutputStream stream; 
    stream << "The answer is " << 42; 
    std::string result; 
    result.swap(stream.str()); 
    std::cout << result << '\n'; 

} 

Hinweis: Sie können die Put-Bereichszeiger in eine anspruchsvollere Implementierung verwalten.

Answer 2

Verschieben Sie es: out = std::move(ostr.str()).