我有一个名为std::string的文件，我想通过std::ostream接口用数据填充它，以避免字符串复制
一种涉及复制的方法是这样做：
bool f(std::string& out)
{
std::ostringstream ostr;
fillWithData(ostr);
out = ostr.str(); // 2 copies here
return true;
}
我需要通过out传递结果，并且不能返回ostr.str()
我想避免out = ostr.str();中的副本，因为这个字符串可能非常大。
是否有某种方法，可能使用rdbuf() s，将std::ostream缓冲区直接绑定到out？
为了澄清，我对std::string和std::ostream的自动扩展行为感兴趣，这样呼叫者就不必在呼叫前知道大小。
更新：我刚刚意识到，无害的行out = ostr.str();可能需要2个副本：
- 第一个由
str()调用 - 另一个由
std::string赋值运算符
编写自己的流：
#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';
}
注意：您可以在更复杂的实现中管理放置区域指针。
以下是我的自定义流缓冲区解决方案https://stackoverflow.com/a/51571896/577234.它比Dieter的要短得多——只需要实现overflow((。通过设置缓冲区，它对重复的ostream:：put((也有更好的性能。使用ostream:：write((进行大型写入的性能将是相同的，因为它调用xsputn((而不是overflow((。
class MemoryOutputStreamBuffer : public streambuf
{
public:
MemoryOutputStreamBuffer(vector<uint8_t> &b) : buffer(b)
{
}
int_type overflow(int_type c)
{
size_t size = this->size(); // can be > oldCapacity due to seeking past end
size_t oldCapacity = buffer.size();
size_t newCapacity = max(oldCapacity + 100, size * 2);
buffer.resize(newCapacity);
char *b = (char *)&buffer[0];
setp(b, &b[newCapacity]);
pbump(size);
if (c != EOF)
{
buffer[size] = c;
pbump(1);
}
return c;
}
#ifdef ALLOW_MEM_OUT_STREAM_RANDOM_ACCESS
streampos MemoryOutputStreamBuffer::seekpos(streampos pos,
ios_base::openmode which)
{
setp(pbase(), epptr());
pbump(pos);
// GCC's streambuf doesn't allow put pointer to go out of bounds or else xsputn() will have integer overflow
// Microsoft's does allow out of bounds, so manually calling overflow() isn't needed
if (pptr() > epptr())
overflow(EOF);
return pos;
}
// redundant, but necessary for tellp() to work
// https://stackoverflow.com/questions/29132458/why-does-the-standard-have-both-seekpos-and-seekoff
streampos MemoryOutputStreamBuffer::seekoff(streamoff offset,
ios_base::seekdir way,
ios_base::openmode which)
{
streampos pos;
switch (way)
{
case ios_base::beg:
pos = offset;
break;
case ios_base::cur:
pos = (pptr() - pbase()) + offset;
break;
case ios_base::end:
pos = (epptr() - pbase()) + offset;
break;
}
return seekpos(pos, which);
}
#endif
size_t size()
{
return pptr() - pbase();
}
private:
std::vector<uint8_t> &buffer;
};
他们说一个好的程序员就是一个懒惰的程序员，所以这里有一个我提出的替代实现，它需要更少的自定义代码。然而，内存泄漏是有风险的，因为它劫持了MyStringBuffer内的缓冲区，但没有释放MySStringBuffer。在实践中，GCC的streambuf不会泄漏，我使用AddressSanitizer确认了这一点。
class MyStringBuffer : public stringbuf
{
public:
uint8_t &operator[](size_t index)
{
uint8_t *b = (uint8_t *)pbase();
return b[index];
}
size_t size()
{
return pptr() - pbase();
}
};
// caller is responsible for freeing out
void Test(uint8_t *&_out, size_t &size)
{
uint8_t dummy[sizeof(MyStringBuffer)];
new (dummy) MyStringBuffer; // construct MyStringBuffer using existing memory
MyStringBuffer &buf = *(MyStringBuffer *)dummy;
ostream out(&buf);
out << "hello world";
_out = &buf[0];
size = buf.size();
}
没有第二个副本，因为它是移动赋值。
由于C++20，std::ostringstream提供了一个新的成员函数，它可以消耗自己并返回std::string:
std::basic_string<CharT,Traits,Allocator> str() &&;
因此，您可以通过以下方式避免第一次复制：
bool f(std::string& out)
{
std::ostringstream ostr;
fillWithData(ostr);
out = std::move(ostr).str();
return true;
}
参考文献
https://en.cppreference.com/w/cpp/io/basic_ostringstream/str