如果我使用std::ostringstream构造一个由空格分隔的浮点值列表组成的字符串：
std::ostringstream ss;
unsigned int s = floatData.size();
for(unsigned int i=0;i<s;i++)
{
ss << floatData[i] << " ";
}
然后我在std::string：
std::string textValues(ss.str());
但是，这会导致不必要的字符串内容深层副本，因为ss将不再使用。
有没有办法在不复制整个内容的情况下构造字符串？
答案 0 :(得分：11)
std::ostringstream没有提供访问其内存缓冲区的公共接口，除非它不支持pubsetbuf（但即使那时你的缓冲区是固定大小的，请参阅cppreference example）
如果你想折磨一些字符串流，你可以使用受保护的接口访问缓冲区：
#include <iostream>
#include <sstream>
#include <vector>
struct my_stringbuf : std::stringbuf {
const char* my_str() const { return pbase(); } // pptr might be useful too
};
int main()
{
std::vector<float> v = {1.1, -3.4, 1/7.0};
my_stringbuf buf;
std::ostream ss(&buf);
for(unsigned int i=0; i < v.size(); ++i)
ss << v[i] << ' ';
ss << std::ends;
std::cout << buf.my_str() << '\n';
}
直接访问自动调整大小的输出流缓冲区的标准C ++方式由std::ostrstream提供，在C ++ 98中已弃用，但仍然是标准C ++ 14并且正在计数。
#include <iostream>
#include <strstream>
#include <vector>
int main()
{
std::vector<float> v = {1.1, -3.4, 1/7.0};
std::ostrstream ss;
for(unsigned int i=0; i < v.size(); ++i)
ss << v[i] << ' ';
ss << std::ends;
const char* buffer = ss.str(); // direct access!
std::cout << buffer << '\n';
ss.freeze(false); // abomination
}
但是，我认为最干净（也是最快）的解决方案是boost.karma
#include <iostream>
#include <string>
#include <vector>
#include <boost/spirit/include/karma.hpp>
namespace karma = boost::spirit::karma;
int main()
{
std::vector<float> v = {1.1, -3.4, 1/7.0};
std::string s;
karma::generate(back_inserter(s), karma::double_ % ' ', v);
std::cout << s << '\n'; // here's your string
}
答案 1 :(得分：3)
我实现了“outstringstream”类，我相信它完全符合你的需要（参见take_str（）方法）。我部分使用了以下代码：What is wrong with my implementation of overflow()?
#include <ostream>
template <typename char_type>
class basic_outstringstream : private std::basic_streambuf<char_type, std::char_traits<char_type>>,
public std::basic_ostream<char_type, std::char_traits<char_type>>
{
using traits_type = std::char_traits<char_type>;
using base_buf_type = std::basic_streambuf<char_type, traits_type>;
using base_stream_type = std::basic_ostream<char_type, traits_type>;
using int_type = typename base_buf_type::int_type;
std::basic_string<char_type> m_str;
int_type overflow(int_type ch) override
{
if (traits_type::eq_int_type(ch, traits_type::eof()))
return traits_type::not_eof(ch);
if (m_str.empty())
m_str.resize(1);
else
m_str.resize(m_str.size() * 2);
const std::ptrdiff_t diff = this->pptr() - this->pbase();
this->setp(&m_str.front(), &m_str.back());
this->pbump(diff);
*this->pptr() = traits_type::to_char_type(ch);
this->pbump(1);
return traits_type::not_eof(traits_type::to_int_type(*this->pptr()));
}
void init()
{
this->setp(&m_str.front(), &m_str.back());
const std::size_t size = m_str.size();
if (size)
{
memcpy(this->pptr(), &m_str.front(), size);
this->pbump(size);
}
}
public:
explicit basic_outstringstream(std::size_t reserveSize = 8)
: base_stream_type(this)
{
m_str.reserve(reserveSize);
init();
}
explicit basic_outstringstream(std::basic_string<char_type>&& str)
: base_stream_type(this), m_str(std::move(str))
{
init();
}
explicit basic_outstringstream(const std::basic_string<char_type>& str)
: base_stream_type(this), m_str(str)
{
init();
}
const std::basic_string<char_type>& str() const
{
return m_str;
}
std::basic_string<char_type>&& take_str()
{
return std::move(m_str);
}
void clear()
{
m_str.clear();
init();
}
};
using outstringstream = basic_outstringstream<char>;
using woutstringstream = basic_outstringstream<wchar_t>;
答案 2 :(得分：3)
@Cubbi的Boost Karma +1和"create your own streambuf-dervied type that does not make a copy, and give that to the constructor of a basic_istream<>."的建议。
虽然缺少一个更通用的答案，但它们介于这两者之间。 它使用Boost Iostreams：
using string_buf = bio::stream_buffer<bio::back_insert_device<std::string> >;
这是一个演示程序：
<强> Live On Coliru
#include <boost/iostreams/device/back_inserter.hpp>
#include <boost/iostreams/stream_buffer.hpp>
namespace bio = boost::iostreams;
using string_buf = bio::stream_buffer<bio::back_insert_device<std::string> >;
// any code that uses ostream
void foo(std::ostream& os) {
os << "Hello world "
<< std::hex << std::showbase << 42
<< " " << std::boolalpha << (1==1) << "\n";
}
#include <iostream>
int main() {
std::string output;
output.reserve(100); // optionally optimize if you know roughly how large output is gonna, or know what minimal size it will require
{
string_buf buf(output);
std::ostream os(&buf);
foo(os);
}
std::cout << "Output contains: " << output;
}
请注意，您可以将
std::string替换为std::wstring或std::vector<char>等。
更好的是，您可以将其与array_sink设备一起使用，并拥有 固定大小 缓冲区。这样你就可以避免使用Iostreams代码进行任何缓冲区分配！
<强> Live On Coliru
#include <boost/iostreams/device/array.hpp>
using array_buf = bio::stream_buffer<bio::basic_array<char>>;
// ...
int main() {
char output[100] = {0};
{
array_buf buf(output);
std::ostream os(&buf);
foo(os);
}
std::cout << "Output contains: " << output;
}
两个程序都打印出来：
Output contains: Hello world 0x2a true
答案 3 :(得分：1)
现在可以在 C++20 中实现，语法如下：
const std::string s = std::move(ss).str();
这是可能的，因为 std::ostringstream 类现在 has a str() overload 是 rvalue-ref 限定：
basic_string<charT, traits, Allocator> str() &&; // since C++20
这是在 P0408 修订版 7 中添加的，即 adopted into C++20。
答案 4 :(得分：0)
更新：面对人们继续不喜欢这个答案，我想我会做一个编辑和解释。
不，没有办法避免字符串副本（stringbuf具有相同的界面）
它永远不会重要。它实际上更有效率。 （我会试着解释一下）
想象一下，编写stringbuf版本，始终保持完美，可移动的std::string。 （我实际上尝试了这个）。
添加字符很简单 - 我们只需在底层字符串上使用push_back即可。
好的，但是删除字符（从缓冲区读取）呢？我们必须移动一些指针来指出我们已删除的字符，一切都很好。
但是，我们遇到了一个问题 - 我们保留的合同说我们总是有std::string可用。
因此，每当我们从流中删除字符时，我们都需要从基础字符串中erase。这意味着将所有剩余的字符向下移动（memmove / memcpy）。因为每次控制流离开我们的私有实现时都必须保留这个契约，这实际上意味着每次我们在字符串缓冲区上调用getc或gets时都必须从字符串中删除字符。这转换为对流上的每个<<操作进行擦除调用。
然后当然存在实现回推缓冲区的问题。如果你将字符推回到底层字符串中，你就必须在0位置insert - 将整个缓冲区移动起来。
它的长短是你可以编写一个仅用于流的缓冲区纯粹用于构建std::string。随着底层缓冲区的增长，您仍然需要处理所有重新分配，因此最终您只需保存一个字符串副本。所以也许我们从4个字符串副本（和调用malloc / free）到3或3到2。
您还需要处理streambuf界面未分为istreambuf和ostreambuf的问题。这意味着您仍然必须提供输入接口，如果有人使用它，则抛出异常或断言。这相当于对用户撒谎 - 我们未能实现预期的界面。
对于性能的微小改进，我们必须支付以下费用：
开发一个（当您考虑区域设置管理时非常复杂）软件组件。
使用仅支持输出操作的streambuf失去灵活性。
为未来的开发商铺设地雷。
答案 5 :(得分：0)
我改编了非常好的@Kuba answer来解决了一些问题（不幸的是，他目前没有反应）。特别是：
safe_pbump来处理64位偏移； string_view而不是string（内部字符串的缓冲区大小不正确）； string方法将take_str调整为当前缓冲区大小； take_str方法在返回之前使用init移动语义； memcpy方法上删除了无用的init； char_type重命名为CharT，以避免与basic_streambuf::char_type产生歧义； string::data()和指针算法，而不使用@LightnessRacesinOrbit指出的使用string::front()和string::back()的可能的未定义行为。#pragma once
#include <cstdlib>
#include <limits>
#include <ostream>
#include <string>
#include <string_view>
namespace usr
{
template <typename CharT>
class basic_outstringstream
: private std::basic_streambuf<CharT, std::char_traits<CharT>>
, public std::basic_ostream<CharT, std::char_traits<CharT>>
{
using traits_type = std::char_traits<CharT>;
using base_buf_type = std::basic_streambuf<CharT, traits_type>;
using base_stream_type = std::basic_ostream<CharT, traits_type>;
using int_type = typename base_buf_type::int_type;
std::basic_string<CharT> m_str;
size_t buffersize() const
{
return (size_t)(this->pptr() - this->pbase());
}
void safe_pbump(std::streamsize off)
{
// pbump doesn't support 64 bit offsets
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=47921
int maxbump;
if (off > 0)
maxbump = std::numeric_limits<int>::max();
else if (off < 0)
maxbump = std::numeric_limits<int>::min();
else // == 0
return;
while (std::abs(off) > std::numeric_limits<int>::max())
{
this->pbump(maxbump);
off -= maxbump;
}
this->pbump((int)off);
}
int_type overflow(int_type ch) override
{
if (traits_type::eq_int_type(ch, traits_type::eof()))
return traits_type::not_eof(ch);
if (m_str.empty())
m_str.resize(1);
else
m_str.resize(m_str.size() * 2);
size_t buffersize = this->buffersize();
this->setp(m_str.data(), m_str.data() + m_str.size());
this->safe_pbump((streamsize)buffersize);
*this->pptr() = traits_type::to_char_type(ch);
this->pbump(1);
return ch;
}
void init()
{
this->setp(m_str.data(), m_str.data() + m_str.size());
this->safe_pbump((streamsize)m_str.size());
}
public:
explicit basic_outstringstream(std::size_t reserveSize = 8)
: base_stream_type(this)
{
m_str.reserve(reserveSize);
init();
}
explicit basic_outstringstream(std::basic_string<CharT>&& str)
: base_stream_type(this), m_str(std::move(str))
{
init();
}
explicit basic_outstringstream(const std::basic_string<CharT>& str)
: base_stream_type(this), m_str(str)
{
init();
}
std::basic_string_view<CharT> str() const
{
return std::basic_string_view<CharT>(m_str.data(), buffersize());
}
std::basic_string<CharT> take_str()
{
// Resize the string to actual used buffer size before
m_str.resize(buffersize());
string ret = std::move(m_str);
init();
return ret;
}
void clear()
{
m_str.clear();
init();
}
};
using outstringstream = basic_outstringstream<char>;
using woutstringstream = basic_outstringstream<wchar_t>;
}