详解C++中StringBuilder类的实现及其性能优化_C 语言

介绍
经常出现客户端打电话抱怨说：你们的程序慢如蜗牛。你开始检查可能的疑点：文件IO，数据库访问速度，甚至查看web服务。 但是这些可能的疑点都很正常，一点问题都没有。
你使用最顺手的性能分析工具分析，发现瓶颈在于一个小函数，这个函数的作用是将一个长的字符串链表写到一文件中。
你对这个函数做了如下优化：将所有的小字符串连接成一个长的字符串，执行一次文件写入操作，避免成千上万次的小字符串写文件操作。
这个优化只做对了一半。
你先测试大字符串写文件的速度，发现快如闪电。然后你再测试所有字符串拼接的速度。
好几年。
怎么回事？你会怎么克服这个问题呢？
你或许知道.net程序员可以使用StringBuilder来解决此问题。这也是本文的起点。

背景

如果google一下“C++ StringBuilder”，你会得到不少答案。有些会建议（你）使用std::accumulate，这可以完成几乎所有你要实现的：

#include <iostream>// for std::cout, std::endl
#include <string> // for std::string
#include <vector> // for std::vector
#include <numeric> // for std::accumulate
int main()
{
  using namespace std;
  vector<string> vec = { "hello", " ", "world" };
  string s = accumulate(vec.begin(), vec.end(), s);
  cout << s << endl; // prints 'hello world' to standard output.
  return 0;
}

目前为止一切都好：当你有超过几个字符串连接时，问题就出现了，并且内存再分配也开始积累。
std::string在函数reserver()中为解决方案提供基础。这也正是我们的意图所在：一次分配，随意连接。
字符串连接可能会因为繁重、迟钝的工具而严重影响性能。由于上次存在的隐患，这个特殊的怪胎给我制造麻烦，我便放弃了Indigo（我想尝试一些C++11里的令人耳目一新的特性），并写了一个StringBuilder类的部分实现：

// Subset of http://msdn.microsoft.com/en-us/library/system.text.stringbuilder.aspx
template <typename chr>
class StringBuilder {
  typedef std::basic_string<chr> string_t;
  typedef std::list<string_t> container_t; // Reasons not to use vector below.
  typedef typename string_t::size_type size_type; // Reuse the size type in the string.
  container_t m_Data;
  size_type m_totalSize;
  void append(const string_t &src) {
    m_Data.push_back(src);
    m_totalSize += src.size();
  }
  // No copy constructor, no assignement.
  StringBuilder(const StringBuilder &);
  StringBuilder & operator = (const StringBuilder &);
public:
  StringBuilder(const string_t &src) {
    if (!src.empty()) {
      m_Data.push_back(src);
    }
    m_totalSize = src.size();
  }
  StringBuilder() {
    m_totalSize = 0;
  }
  // TODO: Constructor that takes an array of strings.

  StringBuilder & Append(const string_t &src) {
    append(src);
    return *this; // allow chaining.
  }
    // This one lets you add any STL container to the string builder.
  template<class inputIterator>
  StringBuilder & Add(const inputIterator &first, const inputIterator &afterLast) {
    // std::for_each and a lambda look like overkill here.
        // <b>Not</b> using std::copy, since we want to update m_totalSize too.
    for (inputIterator f = first; f != afterLast; ++f) {
      append(*f);
    }
    return *this; // allow chaining.
  }
  StringBuilder & AppendLine(const string_t &src) {
    static chr lineFeed[] { 10, 0 }; // C++ 11. Feel the love!
    m_Data.push_back(src + lineFeed);
    m_totalSize += 1 + src.size();
    return *this; // allow chaining.
  }
  StringBuilder & AppendLine() {
    static chr lineFeed[] { 10, 0 };
    m_Data.push_back(lineFeed);
    ++m_totalSize;
    return *this; // allow chaining.
  }

  // TODO: AppendFormat implementation. Not relevant for the article.

  // Like C# StringBuilder.ToString()
  // Note the use of reserve() to avoid reallocations.
  string_t ToString() const {
    string_t result;
    // The whole point of the exercise!
    // If the container has a lot of strings, reallocation (each time the result grows) will take a serious toll,
    // both in performance and chances of failure.
    // I measured (in code I cannot publish) fractions of a second using 'reserve', and almost two minutes using +=.
    result.reserve(m_totalSize + 1);
  // result = std::accumulate(m_Data.begin(), m_Data.end(), result); // This would lose the advantage of 'reserve'
    for (auto iter = m_Data.begin(); iter != m_Data.end(); ++iter) {
      result += *iter;
    }
    return result;
  }

  // like javascript Array.join()
  string_t Join(const string_t &delim) const {
    if (delim.empty()) {
      return ToString();
    }
    string_t result;
    if (m_Data.empty()) {
      return result;
    }
    // Hope we don't overflow the size type.
    size_type st = (delim.size() * (m_Data.size() - 1)) + m_totalSize + 1;
    result.reserve(st);
        // If you need reasons to love C++11, here is one.
    struct adder {
      string_t m_Joiner;
      adder(const string_t &s): m_Joiner(s) {
        // This constructor is NOT empty.
      }
            // This functor runs under accumulate() without reallocations, if 'l' has reserved enough memory.
      string_t operator()(string_t &l, const string_t &r) {
        l += m_Joiner;
        l += r;
        return l;
      }
    } adr(delim);
    auto iter = m_Data.begin();
        // Skip the delimiter before the first element in the container.
    result += *iter;
    return std::accumulate(++iter, m_Data.end(), result, adr);
  }

}; // class StringBuilder

函数ToString()使用std::string::reserve()来实现最小化再分配。下面你可以看到一个性能测试的结果。
函数join()使用std::accumulate()，和一个已经为首个操作数预留内存的自定义函数。
你可能会问，为什么StringBuilder::m_Data用std::list而不是std::vector？除非你有一个用其他容器的好理由，通常都是使用std::vector。
好吧，我（这样做）有两个原因：
1. 字符串总是会附加到一个容器的末尾。std::list允许在不需要内存再分配的情况下这样做；因为vector是使用一个连续的内存块实现的，每用一个就可能导致内存再分配。
2. std::list对顺序存取相当有利，而且在m_Data上所做的唯一存取操作也是顺序的。
你可以建议同时测试这两种实现的性能和内存占用情况，然后选择其中一个。

性能评估

为了测试性能，我从Wikipedia获取一个网页，并将其中一部分内容写死到一个string的vector中。
随后，我编写两个测试函数，第一个在两个循环中使用标准函数clock()并调用std::accumulate()和StringBuilder::ToString()，然后打印结果。

void TestPerformance(const StringBuilder<wchar_t> &tested, const std::vector<std::wstring> &tested2) {
  const int loops = 500;
  clock_t start = clock(); // Give up some accuracy in exchange for platform independence.
  for (int i = 0; i < loops; ++i) {
    std::wstring accumulator;
    std::accumulate(tested2.begin(), tested2.end(), accumulator);
  }
  double secsAccumulate = (double) (clock() - start) / CLOCKS_PER_SEC;

  start = clock();
  for (int i = 0; i < loops; ++i) {
    std::wstring result2 = tested.ToString();
  }
  double secsBuilder = (double) (clock() - start) / CLOCKS_PER_SEC;
  using std::cout;
  using std::endl;
  cout << "Accumulate took " << secsAccumulate << " seconds, and ToString() took " << secsBuilder << " seconds."
      << " The relative speed improvement was " << ((secsAccumulate / secsBuilder) - 1) * 100 << "%"
      << endl;
}

第二个则使用更精确的Posix函数clock_gettime()，并测试StringBuilder::Join()。

#ifdef __USE_POSIX199309

// Thanks to <a href="http://www.guyrutenberg.com/2007/09/22/profiling-code-using-clock_gettime/">Guy Rutenberg</a>.
timespec diff(timespec start, timespec end)
{
  timespec temp;
  if ((end.tv_nsec-start.tv_nsec)<0) {
    temp.tv_sec = end.tv_sec-start.tv_sec-1;
    temp.tv_nsec = 1000000000+end.tv_nsec-start.tv_nsec;
  } else {
    temp.tv_sec = end.tv_sec-start.tv_sec;
    temp.tv_nsec = end.tv_nsec-start.tv_nsec;
  }
  return temp;
}

void AccurateTestPerformance(const StringBuilder<wchar_t> &tested, const std::vector<std::wstring> &tested2) {
  const int loops = 500;
  timespec time1, time2;
  // Don't forget to add -lrt to the g++ linker command line.
  ////////////////
  // Test std::accumulate()
  ////////////////
  clock_gettime(CLOCK_THREAD_CPUTIME_ID, &time1);
  for (int i = 0; i < loops; ++i) {
    std::wstring accumulator;
    std::accumulate(tested2.begin(), tested2.end(), accumulator);
  }
  clock_gettime(CLOCK_THREAD_CPUTIME_ID, &time2);
  using std::cout;
  using std::endl;
  timespec tsAccumulate =diff(time1,time2);
  cout << tsAccumulate.tv_sec << ":" << tsAccumulate.tv_nsec << endl;
  ////////////////
  // Test ToString()
  ////////////////
  clock_gettime(CLOCK_THREAD_CPUTIME_ID, &time1);
  for (int i = 0; i < loops; ++i) {
    std::wstring result2 = tested.ToString();
  }
  clock_gettime(CLOCK_THREAD_CPUTIME_ID, &time2);
  timespec tsToString =diff(time1,time2);
  cout << tsToString.tv_sec << ":" << tsToString.tv_nsec << endl;
  ////////////////
  // Test join()
  ////////////////
  clock_gettime(CLOCK_THREAD_CPUTIME_ID, &time1);
  for (int i = 0; i < loops; ++i) {
    std::wstring result3 = tested.Join(L",");
  }
  clock_gettime(CLOCK_THREAD_CPUTIME_ID, &time2);
  timespec tsJoin =diff(time1,time2);
  cout << tsJoin.tv_sec << ":" << tsJoin.tv_nsec << endl;

  ////////////////
  // Show results
  ////////////////
  double secsAccumulate = tsAccumulate.tv_sec + tsAccumulate.tv_nsec / 1000000000.0;
  double secsBuilder = tsToString.tv_sec + tsToString.tv_nsec / 1000000000.0;
    double secsJoin = tsJoin.tv_sec + tsJoin.tv_nsec / 1000000000.0;
  cout << "Accurate performance test:" << endl << "  Accumulate took " << secsAccumulate << " seconds, and ToString() took " << secsBuilder << " seconds." << endl
      << "  The relative speed improvement was " << ((secsAccumulate / secsBuilder) - 1) * 100 << "%" << endl <<
       "   Join took " << secsJoin << " seconds."
      << endl;
}
#endif // def __USE_POSIX199309

最后，通过一个main函数调用以上实现的两个函数，将结果显示在控制台，然后执行性能测试：一个用于调试配置。

另一个用于发行版本：

看到这百分比没？垃圾邮件的发送量都不能达到这个级别!

代码使用

在使用这段代码前， 考虑使用ostring流。正如你在下面看到Jeff先生评论的一样，它比这篇文章中的代码更快些。
你可能想使用这段代码，如果：
你正在编写由具有C#经验的程序员维护的代码，并且你想提供一个他们所熟悉接口的代码。
你正在编写将来会转换成.net的、你想指出一个可能路径的代码。
由于某些原因，你不想包含<sstream>。几年之后，一些流的IO实现变得很繁琐，而且现在的代码仍然不能完全摆脱他们的干扰。
要使用这段代码，只有按照main函数实现的那样就可以了：创建一个StringBuilder的实例，用Append()、AppendLine()和Add()给它赋值，然后调用ToString函数检索结果。
就像下面这样：

int main() {
  ////////////////////////////////////
  // 8-bit characters (ANSI)
  ////////////////////////////////////
  StringBuilder<char> ansi;
  ansi.Append("Hello").Append(" ").AppendLine("World");
  std::cout << ansi.ToString();

  ////////////////////////////////////
  // Wide characters (Unicode)
  ////////////////////////////////////
  // http://en.wikipedia.org/wiki/Cargo_cult
  std::vector<std::wstring> cargoCult
  {
    L"A", L" cargo", L" cult", L" is", L" a", L" kind", L" of", L" Melanesian", L" millenarian", L" movement",
// many more lines here...
L" applied", L" retroactively", L" to", L" movements", L" in", L" a", L" much", L" earlier", L" era.\n"
  };
  StringBuilder<wchar_t> wide;
  wide.Add(cargoCult.begin(), cargoCult.end()).AppendLine();
    // use ToString(), just like .net
  std::wcout << wide.ToString() << std::endl;
  // javascript-like join.
  std::wcout << wide.Join(L" _\n") << std::endl;

  ////////////////////////////////////
  // Performance tests
  ////////////////////////////////////
  TestPerformance(wide, cargoCult);
#ifdef __USE_POSIX199309
  AccurateTestPerformance(wide, cargoCult);
#endif // def __USE_POSIX199309
  return 0;
}

任何情况下，当连接超过几个字符串时，当心std::accumulate函数。

现在稍等一下！

你可能会问：你是在试着说服我们提前优化吗？
不是的。我赞同提前优化是糟糕的。这种优化并不是提前的：是及时的。这是基于经验的优化：我发现自己过去一直在和这种特殊的怪胎搏斗。基于经验的优化（不在同一个地方摔倒两次）并不是提前优化。

以上是小编为您精心准备的的内容，在的博客、问答、公众号、人物、课程等栏目也有的相关内容，欢迎继续使用右上角搜索按钮进行搜索c++
stringbuilder
stringbuilder性能、stringbuilder、stringbuilder 清空、c stringbuilder、java stringbuilder，以便于您获取更多的相关知识。

时间： 2024-10-28 08:18:34

详解C++中StringBuilder类的实现及其性能优化_C 语言的相关文章

详解C++中new运算符和delete运算符的使用_C 语言

C++ 支持使用 new 和 delete 运算符动态分配和释放对象.这些运算符为来自称为"自由存储"的池中的对象分配内存. new 运算符调用特殊函数 operator new,delete 运算符调用特殊函数 operator delete. 在 Visual C++ .NET 2002 中,标准 C++ 库中的 new 功能将支持 C++ 标准中指定的行为,如果内存分配失败,则会引发 std::bad_alloc 异常. 如果内存分配失败,C 运行库的 new 函数也将引发 st

详解C++中的一维数组和二维数组_C 语言

C++一维数组 定义一维数组 定义一维数组的一般格式为:     类型标识符  数组名[常量表达式]; 例如: int a[10]; 它表示数组名为a,此数组为整型,有10个元素. 关于一维数组的几点说明: 1) 数组名定名规则和变量名相同,遵循标识符定名规则. 2) 用方括号括起来的常量表达式表示下标值,如下面的写法是合法的: int a[10]; int a[2*5]; int a[n*2]; //假设前面已定义了n为常变量 3) 常量表达式的值表示元素的个数,即数组长度.例如,在"int

详解C++中的内联函数和函数重载_C 语言

内联函数(内嵌函数,内置函数) 调用函数时需要一定的时间和空间的开销.C++提供一种提高效率的方法,即在编译时将函数调用处用函数体替换,类似于C语言中的宏展开.这种在函数调用处直接嵌入函数体的函数称为内联函数(inline function),又称内嵌函数或内嵌函数. 指定内联函数的方法很简单,只需要在定义函数时增加 inline 关键字. 注意:是在函数定义时增加 inline 关键字,而不是在函数声明时.在函数声明时增加 inline 关键虽然没有错误,但是也没有任何效果 inline 关键

详解C++中基类与派生类的转换以及虚基类_C 语言

C++基类与派生类的转换 在公用继承.私有继承和保护继承中,只有公用继承能较好地保留基类的特征,它保留了除构造函数和析构函数以外的基类所有成员,基类的公用或保护成员的访问权限在派生类中全部都按原样保留下来了,在派生类外可以调用基类的公用成员函数访问基类的私有成员.因此,公用派生类具有基类的全部功能,所有基类能够实现的功能, 公用派生类都能实现.而非公用派生类(私有或保护派生类)不能实现基类的全部功能(例如在派生类外不能调用基类的公用成员函数访问基类的私有成员).因此,只有公用派生类才是基类真正的

详解C#中委托，事件与回调函数讲解_C#教程

.Net编程中最经常用的元素,事件必然是其中之一.无论在ASP.NET还是WINFrom开发中,窗体加载(Load),绘制(Paint),初始化(Init)等等. "protected void Page_Load(object sender, EventArgs e)"这段代码相信没有人不熟悉的.细心一点一定会发现,非常多的事件方法都是带了"object sender, EventArgs e"这两个参数.这是不是和委托非常相似呢? 一.委托(有些书中也称为委派)

详解C++编程中用数组名作函数参数的方法_C 语言

C++数组的概念 概括地说:数组是有序数据的集合.要寻找一个数组中的某一个元素必须给出两个要素,即数组名和下标.数组名和下标惟一地标识一个数组中的一个元素. 数组是有类型属性的.同一数组中的每一个元素都必须属于同一数据类型.一个数组在内存中占一片连续的存储单元.如果有一个整型数组a,假设数组的起始地址为2000,则该数组在内存中的存储情况如图所示. 引入数组就不需要在程序中定义大量的变量,大大减少程序中变量的数量,使程序精炼,而且数组含义清楚,使用方便,明确地反映了数据间的联系.许多好的算法都与

详解C语言中的getgrgid()函数和getgrnam()函数_C 语言

C语言getgrgid()函数:从组文件中取得指定gid的数据 头文件: #include <grp.h> #include <sys/types.h> 定义函数: strcut group * getgrgid(gid_t gid); 函数说明:getgrgid()用来依参数gid 指定的组识别码逐一搜索组文件, 找到时便将该组的数据以group 结构返回. 返回值:返回 group 结构数据, 如果返回NULL 则表示已无数据, 或有错误发生. 范例 /* 取得gid＝3 的组

分享C++面试中string类的一种正确写法_C 语言

具体来说: 能像 int 类型那样定义变量,并且支持赋值.复制. 能用作函数的参数类型及返回类型. 能用作标准库容器的元素类型,即 vector/list/deque 的 value_type.(用作 std::map 的 key_type 是更进一步的要求,本文从略). 换言之,你的 String 能让以下代码编译运行通过,并且没有内存方面的错误. 复制代码 代码如下: void foo(String x)  {  }  void bar(const String& x)  {  }  Str

MFC扩展DLL中导出类和对话框的实现方法_C 语言

本文实例讲述了MFC扩展DLL中导出类和对话框的实现方法,分享给大家供大家参考.具体实现方法如下: 一般来说,如果要编写模块化的软件,就要对对动态链接库(DLL)有一定的了解,本人这段时间在修改以前的软件时,决定把重复用的类和对话框做到DLL中,下面就从一个简单的例子讲起,如何实现MFC扩展DLL中导出类和对话框. 程序运行结果如下图所示: 一.创建MFC扩展DLL 步骤: 运行Visual Studio 6.0->File->New...->Projects: 选择Mfc AppWiz