5种方式初始化String成员怎样选择？

C++初始化成员的方式有许多，尤其是随着C++11值类别的重新定义，各种方式之间的差异更是细微。

• call by-const-reference

• call by-value

• two-overloads

• std::string_view

• forwarding references

1call by-const-reference

这种方式最是广为流传，C++11之前亦可使用，是早期的推荐方式。

比如：

structS{
std::stringmem;
S(conststd::string&s):mem{s}{}
};

根据4种不同的输入分析其开销，代码如下：

std::stringstr{"dummy"};
Ss1("dummy");//1.Implicitctor
Ss2(str);//2.lvalue
Ss3(std::move(str));//3.xvalue
Ss4(std::string{"dummy"});//4.prvalue

第二，lvalue。对于左值，将直接绑定到形参上，再通过拷贝构造复制到成员变量。共1次分配。

第三，xvalue。对于消亡值，操作同上。共1次分配。

第四，prvalue。对于纯右值，操作同上。共1次分配。

由此可知，使用const-reference string时，至少存在1次分配。对于左值来说，这本无可厚非；但对于右值来说，这将徒增一次没必要的拷贝；对于字符串字面量，还会由隐式构造创建一个临时对象，增加一次开销。

因此，这种方式只有针对左值时，效果才不错，其他情况都会增加一次开销。

2call by-value

structS{
std::stringmem;
S(std::strings):mem{std::move(s)}{}
};

3Two-overloads

structS{
std::stringmem;
S(conststd::string&s):mem{s}{}
S(std::string&&s):mem{std::move(s)}{}
};

4C++17 string_view

structS{
std::stringmem;
S(std::string_views):mem{s}{}
};

5Fowarding references

Forwarding references可以自动匹配左值或是右值版本，也是一种不错的方式。

实现变为：

structS{
std::stringmem;
template<classT>
S(T&&s):mem{std::forward(s)}{}
};

6曲未尽

分析至此，已然可以初步得出一张开销对比图。

看情况。

没有哪种方式是完全占优的，可以依据使用次数最多的操作计算消耗，从而正确决策。

举个例子：

structS{
usingvalue_type=std::vector<std::string>;
usingassoc_type=std::map<std::string,value_type>;

voidpush_data(std::string_viewkey,value_typedata){
datasets.emplace(std::make_pair(key,std::move(data)));
}

assoc_typedatasets;
};

假设我们后面使用次数最多的操作为：

Ss;
s.push_data("key1",{"Dear","Friend"});
s.push_data("key2",{"Apple"});
s.push_data("key3",{"Jack","Tom","Jerry"});
s.push_data("key4",{"20","22","11","20"});

voidpush_data(auto&&key,auto&&data){
datasets.emplace(std::make_pair(
std::forward<decltype(key)>(key),
std::forward<decltype(data)>(data)
));
}

6.1SSO短字符串优化

各家编译器在实现std::string时，基本都会采取一种SSO(Small String Optimization)策略。

此时，对于短字符串，将不会在堆上额外分配内存，而是直接存储在栈上。比如，有些实现会在size的最低标志位上用1代表长字符串，0代表短字符串，根据这个标志位来决定操作形式。

std::size_tallocated=0;

void*operatornew(size_tsz){
void*p=std::malloc(sz);
allocated+=sz;
returnp;
}

voidoperatordelete(void*p)noexcept{
returnstd::free(p);
}

intmain(){
allocated=0;
std::strings("hi");
std::printf("stackspace=%zu,heapspace=%zu,capacity=%zu
",
sizeof(s),allocated,s.capacity());
}
例子来源：https://stackoverflow.com/a/28003328

stackspace=32,heapspace=0,capacity=15

可以看到，对于短字符串，将不会在堆上分配额外的内存，内容实际存在在栈上。

早期版本的编译器可能没有这种优化，但如今的版本基本都有。

于是可以得出结论：尽管小对象的拷贝操作很快，call by-value还是要慢于其他方式，string_view则是一种较好的方式。

但是，string_view使用起来要格外当心，若你不想为此操心，使用call by-const-reference则是一种不错的方式。

6.2无拷贝，无移动

当仅需要接受参数，之后即不拷贝，也无移动的情境下，情况又不一样。

此时的开销如下图。

6.3优化限制：Aliasing situations

Aliasing situations指的是多个变量实际指向的是同一块内存，这些变量之间互为别名。这种情况会导致编译器束手束脚，不敢优化。

以引用的方式传递参数便会产生许多额外的Aliasing situations。

举个例子：

intfoo_by_ref(constS&s){
intm=s.value;
bar();
intn=s.value;
returnm+n;
}

intfoo_by_value(Ss){
intm=s.value;
bar();
intn=s.value;
returnm+n;
}

例子来源：https://reductor.dev/cpp/2022/06/27/pass-by-value-vs-pass-by-reference.html

引用传递版本，编译器无法判定bar()中是否修改了s.value，比如s引用的是一个全局变量，bar()中就可以修改它。因此，m和n的值可能并不相同，编译器必须加载两次s.value。

而值传递版本，由于参数进行了拷贝，不存在外部修改，m和n的值肯定相同，于是编译器可以优化为只加载一次s.value。

这是call by-const-reference的另一处缺点，它可能会限制编译器的优化，而这又恰恰成了call by-value的一个优点。

7总结

本篇文章介绍了5种初始化String成员的方式，详细分析对比了它们的开销。

没有哪种方式是最优解，如何选择需要依具体情况而论。

Two-overloads这种方式一般不会考虑，因为总有其他方式比它的开销更小，还只需编写一个函数。

string_view在很多情况下的开销可观，但是需要格外注意潜在的悬垂引用问题。

其他三种方式亦是有利有弊，可根据文中提及的各种情况进行分析。

总而言之，各方式之间存在着细微而本质的差别，且还有许多特殊情况需要单独分析，开销在不同情境下也不尽相同。

审核编辑 ：李倩