StringBuffer/StringBuilder?

您可以使用.append()简单地连接字符串。

std::string s = "string1";
s.append("string2");

我认为你甚至可以做到:

std::string s = "string1";
s += "string2";

至于c#的StringBuilder的格式化操作，我相信snprintf(或者sprintf，如果你想冒险编写有bug的代码;-))转换成字符数组并转换回字符串是唯一的选择。

c++的方法是使用std:: stringstream或只是简单的字符串连接。c++字符串是可变的，因此连接的性能考虑不是那么重要。

关于格式化，你可以在一个流上做所有相同的格式化，但以不同的方式，类似于cout。或者你可以使用强类型函子封装这个并提供一个String。格式类似于接口，例如boost::格式

这个答案最近受到了一些关注。我并不是提倡将其作为一种解决方案(这是我过去在STL之前见过的解决方案)。这是一个有趣的方法，如果在分析你的代码后，你发现这样做有改进，那么只应该应用在std::string或std::stringstream上。

我通常使用std::string或std::stringstream。我从来没有遇到过任何问题。如果我事先知道弦的大致大小，我通常会先预留一些空间。

在遥远的过去，我见过其他人制作他们自己优化的字符串构建器。

class StringBuilder {
private:
std::string main;
std::string scratch;


const std::string::size_type ScratchSize = 1024;  // or some other arbitrary number


public:
StringBuilder & append(const std::string & str) {
scratch.append(str);
if (scratch.size() > ScratchSize) {
main.append(scratch);
scratch.resize(0);
}
return *this;
}


const std::string & str() {
if (scratch.size() > 0) {
main.append(scratch);
scratch.resize(0);
}
return main;
}
};

它使用两个字符串，一个用于字符串的大部分，另一个用作连接短字符串的划痕区域。它通过将短的追加操作批处理在一个小字符串中，然后将其追加到主字符串中来优化追加，从而减少主字符串变大时所需的重新分配数量。

我对std::string或std::stringstream不需要这个技巧。我认为它是在std::string之前与第三方字符串库一起使用的，这是很久以前的事了。如果您采用这样的策略，则首先对应用程序进行概要分析。

std::string 是 c++等价:它是可变的。

std::string.append函数不是一个好的选择，因为它不接受许多形式的数据。更有用的替代方法是使用std::stringstream;像这样:

#include <sstream>
// ...


std::stringstream ss;


//put arbitrary formatted data into the stream
ss << 4.5 << ", " << 4 << " whatever";


//convert the stream buffer into a string
std::string str = ss.str();

因为c++中的std::string是可变的，你可以使用它。它有一个+= operator和一个append函数。

如果需要附加数值数据，请使用std::to_string函数。

如果你想要以能够将任何对象序列化为字符串的形式获得更大的灵活性，那么可以使用std::stringstream类。但是你需要实现你自己的流操作符函数，让它与你自己的自定义类一起工作。

Std::string的+=不能与const char*(像“string to add”这样的东西看起来是什么)一起工作，所以使用stringstream是最接近所需要的-你只需要使用<<而不是+

crope r(1000000, 'x');          // crope is rope<char>. wrope is rope<wchar_t>
// Builds a rope containing a million 'x's.
// Takes much less than a MB, since the
// different pieces are shared.
crope r2 = r + "abc" + r;       // concatenation; takes on the order of 100s
// of machine instructions; fast
crope r3 = r2.substr(1000000, 3);       // yields "abc"; fast.
crope r4 = r2.substr(1000000, 1000000); // also fast.
reverse(r2.mutable_begin(), r2.mutable_end());
// correct, but slow; may take a
// minute or more.

我想添加一些新的东西，因为以下原因:

我第一次尝试就失败了

std::ostringstream的operator<<

效率，但通过更多的尝试，我能够使一个StringBuilder在某些情况下更快。

每次我添加一个字符串时，我只是在某个地方存储一个对它的引用，并增加总大小的计数器。

我最终实现它的真正方式(恐怖!)是使用一个不透明的缓冲区(std::vector <Char >):

• 1字节报头(2位来告诉以下数据是:移动的字符串，字符串还是字节[])
• 6位表示字节的长度[]

对于byte []

• 我直接存储短字符串的字节(用于顺序内存访问)

对于移动的字符串(附加std::move的字符串)

• 指向std::string对象的指针(我们拥有所有权)
• 如果有未使用的保留字节，在类中设置一个标志

为字符串

• 指向std::string对象的指针(无所有权)

还有一个小优化，如果最后插入的字符串被移动，它检查自由保留但未使用的字节，并存储进一步的字节在那里，而不是使用不透明缓冲区(这是为了节省一些内存，它实际上使它稍微慢一点，可能也取决于CPU，而且很少看到字符串有额外的预留空间)

这最终比std::ostringstream略快，但它有一些缺点:

• 我假设固定长度的字符类型(所以1,2或4字节，不适合UTF8)，我不是说它不会为UTF8工作，只是我没有检查它的懒惰。
• 我使用了糟糕的编码实践(不透明的缓冲区，容易使它无法移植，顺便说一句，我相信我的是可移植的)
• 缺少ostringstream的所有特性
• 如果在合并所有字符串之前删除了一些引用的字符串:未定义行为。

它已经解决了最大的瓶颈，而在矿的实现速度上提高了几个百分点是不值得的。

c++中一个方便的字符串构建器

std::stringstream ss;
ss << "my data " << 42;
std::string myString( ss.str() );

这很烦人，尤其是当你想在构造函数中初始化字符串的时候。

原因是:a) std::stringstream没有转换到std::string的操作符;b)操作符<stringstream的()不会返回stringstream引用，而是返回std::ostream引用——它不能进一步作为字符串流计算。

解决方案是重写std::stringstream并给它更好的匹配操作符:

namespace NsStringBuilder {
template<typename T> class basic_stringstream : public std::basic_stringstream<T>
{
public:
basic_stringstream() {}


operator const std::basic_string<T> () const                                { return std::basic_stringstream<T>::str();                     }
basic_stringstream<T>& operator<<   (bool _val)                             { std::basic_stringstream<T>::operator << (_val); return *this; }
basic_stringstream<T>& operator<<   (char _val)                             { std::basic_stringstream<T>::operator << (_val); return *this; }
basic_stringstream<T>& operator<<   (signed char _val)                      { std::basic_stringstream<T>::operator << (_val); return *this; }
basic_stringstream<T>& operator<<   (unsigned char _val)                    { std::basic_stringstream<T>::operator << (_val); return *this; }
basic_stringstream<T>& operator<<   (short _val)                            { std::basic_stringstream<T>::operator << (_val); return *this; }
basic_stringstream<T>& operator<<   (unsigned short _val)                   { std::basic_stringstream<T>::operator << (_val); return *this; }
basic_stringstream<T>& operator<<   (int _val)                              { std::basic_stringstream<T>::operator << (_val); return *this; }
basic_stringstream<T>& operator<<   (unsigned int _val)                     { std::basic_stringstream<T>::operator << (_val); return *this; }
basic_stringstream<T>& operator<<   (long _val)                             { std::basic_stringstream<T>::operator << (_val); return *this; }
basic_stringstream<T>& operator<<   (unsigned long _val)                    { std::basic_stringstream<T>::operator << (_val); return *this; }
basic_stringstream<T>& operator<<   (long long _val)                        { std::basic_stringstream<T>::operator << (_val); return *this; }
basic_stringstream<T>& operator<<   (unsigned long long _val)               { std::basic_stringstream<T>::operator << (_val); return *this; }
basic_stringstream<T>& operator<<   (float _val)                            { std::basic_stringstream<T>::operator << (_val); return *this; }
basic_stringstream<T>& operator<<   (double _val)                           { std::basic_stringstream<T>::operator << (_val); return *this; }
basic_stringstream<T>& operator<<   (long double _val)                      { std::basic_stringstream<T>::operator << (_val); return *this; }
basic_stringstream<T>& operator<<   (void* _val)                            { std::basic_stringstream<T>::operator << (_val); return *this; }
basic_stringstream<T>& operator<<   (std::streambuf* _val)                  { std::basic_stringstream<T>::operator << (_val); return *this; }
basic_stringstream<T>& operator<<   (std::ostream& (*_val)(std::ostream&))  { std::basic_stringstream<T>::operator << (_val); return *this; }
basic_stringstream<T>& operator<<   (std::ios& (*_val)(std::ios&))          { std::basic_stringstream<T>::operator << (_val); return *this; }
basic_stringstream<T>& operator<<   (std::ios_base& (*_val)(std::ios_base&)){ std::basic_stringstream<T>::operator << (_val); return *this; }
basic_stringstream<T>& operator<<   (const T* _val)                         { return static_cast<basic_stringstream<T>&>(std::operator << (*this,_val)); }
basic_stringstream<T>& operator<<   (const std::basic_string<T>& _val)      { return static_cast<basic_stringstream<T>&>(std::operator << (*this,_val.c_str())); }
};


typedef basic_stringstream<char>        stringstream;
typedef basic_stringstream<wchar_t>     wstringstream;
}

有了这个，你可以写

std::string myString( NsStringBuilder::stringstream() << "my data " << 42 )

甚至在构造函数中。

我必须承认我没有衡量性能，因为我还没有在一个环境中使用它大量使用字符串构建，但我认为它不会比std::stringstream差很多，因为一切都是通过引用完成的(除了转换为字符串，但这是一个复制操作在std::stringstream)