Question

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

Answer 1

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

关于格式化，您可以在流上执行所有相同的格式设置，但in a different way, similar to 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::string或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

由于C ++中的std::string是可变的，你可以使用它。它有+= operator和append函数。

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

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

Answer 7

std :: string的+ =不能用于const char *（类似“要添加的字符串”之类的东西），所以绝对使用stringstream最接近需要的东西 - 你只需使用＆lt;＆lt;而不是+

Answer 8

c ++的便捷字符串构建器

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

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

这非常烦人，特别是当你想在构造函数中初始化字符串时。

原因是，a）std :: stringstream没有转换运算符到std :: string和b）运算符＆lt;＆lt; （）的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 9

如果必须在目标字符串的随机位置或长字符序列中插入/删除字符串，Rope容器可能是值得的。以下是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的{{1}}

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

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

我最终实现它的真正方式（恐怖！）是使用不透明的缓冲区（std :: vector＆lt; char＆gt;）：

1字节标头（2位用于判断后续数据是：移动字符串，字符串还是字节[]）
6比特来告诉字节[]

for byte []

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

用于移动字符串（附加operator<<的字符串）

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

表示字符串

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

还有一个小优化，如果最后插入的字符串是mov'd，它会检查免费保留但未使用的字节并在那里存储更多字节而不是使用不透明缓冲区（这是为了节省一些内存，它实际上是它稍慢，也可能依赖于CPU，并且很少看到带有额外保留空间的字符串）

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

我假设固定长度字符类型（1,2或4字节，对UTF8不好），我不是说它不适用于UTF8，只是我没有检查它是否懒惰。
我使用了错误的编码练习（不透明的缓冲区，很容易使它不便携，我相信我的便携式）
缺少std::ostringstream
如果在mergin之前删除了一些引用的字符串，则所有字符串都是：undefined behavior。

结论呢？使用 ostringstream

它已经解决了最大的瓶颈，同时在矿井实施方面加快了几个百分点的速度并不值得下降。

C ++相当于StringBuffer / StringBuilder？

10 个答案: