避免临时对象的字符串加法
之前我有一篇文章《 C++中让对象的拷贝成为 显式 的》，使用类似的技巧，可以避免字符串加法中的临时对象，也许是因为惰性，这个想法一直没有诉诸实现，今天有空把它写了出来。
先看看这段代码：
|
1 2 |
std::string a = "A"; std::string b = a + "B" + "C" + "D" + "E" + "F"; |
在C++11之前的标准 C++1998/2003 中，为了计算 b，这段代码一共创建了 5 个临时 std::string 对象。
实现代码非常简单：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
#include <string> template<class String> class strjoin_helper { private: String v; typedef typename String::value_type char_t; typedef strjoin_helper me; public: template<class StrX> explicit strjoin_helper(const StrX& x) : v(x) {} template<class Char> explicit strjoin_helper(const Char* s, ptrdiff_t n) : v(s, n) {} operator String() const { return v; } me& operator+(const String& y) { v += y; return *this; } me& operator+(const char_t* y) { v += y; return *this; } me& operator+(const me& y) { v += y.v; return *this; } friend me operator+(const char_t* x, const me& y) { me t(x); t.v += y.v; return t; } friend me operator+(const String& x, const me& y) { me t(x); t.v += y.v; return t; } }; template<class AnyString> strjoin_helper<AnyString> strjoin(const AnyString& x) { return strjoin_helper<AnyString>(x); } strjoin_helper<std::string> strjoin(const char* s) { return strjoin_helper<std::string>(s); } strjoin_helper<std::string> strjoin(const char* s, ptrdiff_t n) { return strjoin_helper<std::string>(s, n); } strjoin_helper<std::wstring> strjoin(const wchar_t* s) { return strjoin_helper<std::wstring>(s); } strjoin_helper<std::wstring> strjoin(const wchar_t* s, ptrdiff_t n) { return strjoin_helper<std::wstring>(s, n); } |
使用的时候更简单：
|
1 2 3 4 5 6 7 |
using namespace std; int main() { string a = "123_" + strjoin("") + "A" + "B" + strjoin("abc") + strjoin("012345", 4); cout << a << endl; return 0; } |
用一个简单的程序测一下性能，这个程序的输出结果：
loop=1000000: fast[temp_cnt=2000002 time=0.715966] slow[temp_cnt=10000002 time=1.305356]
总结
strjoin 使用了两个 C++1998 中鲜为人知的特性：
- 如 《C++ 中让对象的拷贝成为 显式 的》中所说，临时对象可以被修改，但不能绑定到非常量引用上
- 临时对象的生存期为整个表达式，而不是某个真子表达式
这样的写法，似乎不如str.append(…)高效；
code:
string a;
string b = "A";
boost::chrono::high_resolution_clock::time_point t0 = boost::chrono::high_resolution_clock::now();
for(){
method1:
a = b + "123_" + strjoin("") + "A" + "B" + strjoin("abc") + strjoin("012345", 4);
method2：
a = b + "123_" + "A" + "B" + ("abc") + std::string("012345", 4);
method3:
a = b + "123_";
a+="A";
a+= "B";
a+=("abc");
a+=std::string("012345", 4);
method4:
a = b + "123_";
a.append("A");
a.append("B");
a.append("abc");
a.append(std::string("012345", 4));
}
boost::chrono::high_resolution_clock::time_point t1 = boost::chrono::high_resolution_clock::now();
cout << "That took " << t1 – t0 << 'n';
结果：
method1 最慢； 3 4差不多，性能最好；
测试环境： windows7 64x advance
IDE：vs 2010
CPU:2720QM
vs 2010 c++ 支持 C++11，有 右值引用，右值引用几乎可以避免所有临时对象，我这个技巧是针对无右值引用的C++编译器的