c++ - C++ 等价于 StringBuffer/StringBuilder？

Question

是否有提供高效字符串连接功能的 C++ 标准模板库类，类似于 C# 的StringBuilder或 Java 的StringBuffer？

Answer 1

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

关于格式化，您可以对流进行所有相同的格式化，但方式不同，类似于cout. 或者你可以使用一个强类型的函子来封装它并提供一个类似 String.Format 的接口，例如boost::format

Answer 2

该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();

Answer 3

注意这个答案最近受到了一些关注。我不提倡将此作为解决方案（这是我过去在 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::stringor std::stringstream。我认为它是在 std::string 之前与第三方字符串库一起使用的，那是很久以前的事了。如果您采用这样的策略，请先配置您的应用程序。

Answer 4

std::string 是C++ 等价物：它是可变的。

Answer 5

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

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

我想你甚至可以做到：

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

至于 C# 的格式化操作StringBuilder，我相信snprintf（或者sprintf如果您想冒险编写错误代码 ;-) ）到字符数组并转换回字符串是唯一的选择。

Answer 6

由于std::string在 C++ 中是可变的，您可以使用它。它有一个+= operator和一个append功能。

如果您需要附加数字数据，请使用这些std::to_string函数。

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

Answer 7

一个方便的 c++ 字符串生成器

就像许多人之前回答的那样， std::stringstream 是首选方法。它工作得很好，并且有很多转换和格式化选项。IMO 虽然它有一个非常不方便的缺陷：你不能将它用作一个衬里或作为一种表达方式。你总是必须写：

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 中的复制操作）

Answer 8

std::string 的 += 不适用于 const char* （看起来像“要添加的字符串”之类的东西），所以绝对使用 stringstream 是最接近所需的 - 你只需使用 << 而不是 +

Answer 9

如果必须将字符串插入/删除目标字符串的随机位置或长字符序列，绳子容器可能是值得的。以下是 SGI 实现的示例：

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.

Answer 10

由于以下原因，我想添加一些新内容：

在第一次尝试时我未能击败

std::ostringstream的operator<<

效率，但通过更多尝试，我能够制作出在某些情况下更快的 StringBuilder。

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

我最终实现它的真正方法（恐怖！）是使用不透明缓冲区（std::vector < char >）：

• 1 字节标头（2 位来判断以下数据是：移动的字符串、字符串还是字节 []）
• 6 位来判断字节 [] 的长度

对于字节 [ ]

• 我直接存储短字符串字节（用于顺序内存访问）

对于移动的字符串（带有 的字符串std::move）

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

对于字符串

• 指向std::string对象的指针（无所有权）

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

这最终比它稍微快了一点，std::ostringstream但它几乎没有缺点：

• 我假设固定长度的字符类型（所以 1,2 或 4 个字节，不适合 UTF8），我并不是说它不适用于 UTF8，只是我没有检查它是否懒惰。
• 我使用了糟糕的编码实践（不透明的缓冲区，很容易使它不便携，顺便说一下我相信我的是便携的）
• 缺乏所有功能ostringstream
• 如果在合并所有字符串之前删除了某个引用的字符串：未定义的行为。

结论？采用 std::ostringstream

它已经解决了最大的瓶颈，同时在我的实施中获得了几个百分点的速度是不值得的缺点。