之前我有一篇文章《 C++ 中让对象的拷贝成为 显式 的》,使用类似的技巧,可以避免字符串加法中的临时对象,也许是因为惰性,这个想法一直没有诉诸实现,今天有空把它写了出来。
先看看这段代码:
std::string a = "A";
std::string b = a + "B" + "C" + "D" + "E" + "F";
在C++11之前的标准 C++1998/2003 中,为了计算 b, 这段代码一共创建了 5 个临时 std::string 对象。
实现代码非常简单:
#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); }
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++ 中让对象的拷贝成为 显式 的》中所说,临时对象可以被修改,但不能绑定到非常量引用上
- 临时对象的生存期为整个表达式,而不是某个真子表达式