如果我使用以下方法构造一个由空格分隔的浮点值列表组成的字符串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将不再使用。
有没有办法在不复制整个内容的情况下构造字符串？
std::ostringstream除非它不可移植地支持，否则不提供访问其内存缓冲区的公共接口pubsetbuf（但即便如此，您的缓冲区也是固定大小的，请参阅cppreference 示例）
如果你想折磨一些字符串流，你可以使用受保护的接口访问缓冲区：
#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
}
这现在可以通过 C++20 实现，语法如下：
const std::string s = std::move(ss).str();
这是可能的，因为std::ostringstream该类现在具有 rvalue-ref 限定的str()重载：
basic_string<charT, traits, Allocator> str() &&; // since C++20
+1 为@Cubbi 的 Boost Karma 以及“创建自己的streambuf不复制的衍生类型，并将其提供给 a 的构造函数”的建议basic_istream<>。.
但是，缺少一个更通用的答案，并且位于这两者之间。它使用 Boost Iostreams：
using string_buf = bio::stream_buffer<bio::back_insert_device<std::string> >;
这是一个演示程序：
#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 代码进行任何缓冲区分配！
#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
我实现了“outstringstream”类，我相信它完全符合您的需要（参见 take_str() 方法）。我部分使用了以下代码：我的溢出（）的实现有什么问题？
#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>;
更新：面对人们继续不喜欢这个答案，我想我会进行编辑和解释。
不，没有办法避免字符串复制（stringbuf 具有相同的接口）
这永远不会有关系。这种方式实际上效率更高。（我将尝试解释这一点）
想象一下，编写一个stringbuf始终保持完美、可移动的版本std::string。（我实际上已经尝试过）。
添加字符很容易——我们只需push_back在底层字符串上使用。
好的，但是删除字符（从缓冲区读取）呢？我们必须移动一些指针来说明我们已删除的字符，一切都很好。
然而，我们有一个问题——我们保留的合同说我们总是有一个std::string可用的。
因此，每当我们从流中删除字符时，我们都需要erase从底层字符串中删除它们。这意味着将所有剩余的字符向下移动（memmove/ memcpy）。因为每次控制流离开我们的私有实现时都必须保留这个合约，这实际上意味着每次我们调用getc或gets在字符串缓冲区上都必须从字符串中删除字符。这转化为对流上的每个<<操作的擦除调用。
然后当然还有实现推回缓冲区的问题。如果您将字符推回底层字符串，您insert将在位置 0 找到它们 - 将整个缓冲区重新洗牌。
总而言之，您可以编写一个仅用于 ostream 的流缓冲区，纯粹用于构建std::string. 随着底层缓冲区的增长，您仍然需要处理所有重新分配，因此最终您可以只保存一个字符串副本。所以也许我们从 4 个字符串副本（以及对 malloc/free 的调用）到 3 个，或者从 3 个到 2 个。
您还需要处理 streambuf 接口未拆分为istreambufand的问题ostreambuf。这意味着您仍然必须提供输入接口，并且如果有人使用它，则抛出异常或断言。这相当于对用户撒谎——我们未能实现预期的界面。
为了性能上的这种微小提升，我们必须付出以下代价：
开发一个（相当复杂，当您考虑区域设置管理时）软件组件。
失去了只支持输出操作的流缓冲区的灵活性。
为未来的开发商埋下地雷。
我改编了非常好的@Kuba答案来解决一些问题（不幸的是他目前没有反应）。尤其是：
safe_pbump来处理 64 位偏移；string_view而不是string（内部字符串的缓冲区大小不正确）；string在移动语义take_str方法上调整当前缓冲区大小；take_str移动语义；initmemcpy的 oninit方法；char_type以CharT避免歧义basic_streambuf::char_typestring::data()和指针算术，而不是使用string::front()和string::back()@LightnessRacesinOrbit 所指出的可能未定义的行为；streambuf。#pragma once
#include <cstdlib>
#include <limits>
#include <ostream>
#include <string>
#if __cplusplus >= 201703L
#include <string_view>
#endif
namespace usr
{
template <typename CharT>
class basic_outstringstream : public std::basic_ostream<CharT, std::char_traits<CharT>>
{
using traits_type = std::char_traits<CharT>;
using base_stream_type = std::basic_ostream<CharT, traits_type>;
class buffer : public std::basic_streambuf<CharT, std::char_traits<CharT>>
{
using base_buf_type = std::basic_streambuf<CharT, traits_type>;
using int_type = typename base_buf_type::int_type;
private:
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);
}
void init()
{
this->setp(const_cast<CharT *>(m_str.data()),
const_cast<CharT *>(m_str.data()) + m_str.size());
this->safe_pbump((std::streamsize)m_str.size());
}
protected:
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 size = this->size();
this->setp(const_cast<CharT *>(m_str.data()),
const_cast<CharT *>(m_str.data()) + m_str.size());
this->safe_pbump((std::streamsize)size);
*this->pptr() = traits_type::to_char_type(ch);
this->pbump(1);
return ch;
}
public:
buffer(std::size_t reserveSize)
{
m_str.reserve(reserveSize);
init();
}
buffer(std::basic_string<CharT>&& str)
: m_str(std::move(str))
{
init();
}
buffer(const std::basic_string<CharT>& str)
: m_str(str)
{
init();
}
public:
size_t size() const
{
return (size_t)(this->pptr() - this->pbase());
}
#if __cplusplus >= 201703L
std::basic_string_view<CharT> str() const
{
return std::basic_string_view<CharT>(m_str.data(), size());
}
#endif
std::basic_string<CharT> take_str()
{
// Resize the string to actual used buffer size
m_str.resize(size());
std::string ret = std::move(m_str);
init();
return ret;
}
void clear()
{
m_str.clear();
init();
}
const CharT * data() const
{
return m_str.data();
}
private:
std::basic_string<CharT> m_str;
};
public:
explicit basic_outstringstream(std::size_t reserveSize = 8)
: base_stream_type(nullptr), m_buffer(reserveSize)
{
this->rdbuf(&m_buffer);
}
explicit basic_outstringstream(std::basic_string<CharT>&& str)
: base_stream_type(nullptr), m_buffer(str)
{
this->rdbuf(&m_buffer);
}
explicit basic_outstringstream(const std::basic_string<CharT>& str)
: base_stream_type(nullptr), m_buffer(str)
{
this->rdbuf(&m_buffer);
}
#if __cplusplus >= 201703L
std::basic_string_view<CharT> str() const
{
return m_buffer.str();
}
#endif
std::basic_string<CharT> take_str()
{
return m_buffer.take_str();
}
const CharT * data() const
{
return m_buffer.data();
}
size_t size() const
{
return m_buffer.size();
}
void clear()
{
m_buffer.clear();
}
private:
buffer m_buffer;
};
using outstringstream = basic_outstringstream<char>;
using woutstringstream = basic_outstringstream<wchar_t>;
}