C++:完美转发(二)(std::forward)

一、RVO优化和std::move、std::forward

以下是一个综合性的例子:

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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
#include <iostream>
#include <memory>
#include <ostream>
using namespace std;

// 1. 针对右值引用实施std::move,针对万能引用实施std::forward
class Data {};

class Widget {
std::string name;
std::shared_ptr<Data> ptr;

public:
Widget() {cout << "Widget() used for object@" << this
<< " addr_name: " << &(this->name) <<" string buffer addr: "<< static_cast<const void*>(this->name.data())<< endl;};

//复制构造函数
Widget(const Widget &w) : name(w.name), ptr(w.ptr) {
cout << "Widget(const Widget& w) used for object@" << this
<< " addr_name: " << &(this->name) <<" string buffer addr: "<< static_cast<const void*>(this->name.data())<< endl;
}
//针对右值引用使用std::move
Widget(Widget &&rhs) noexcept
: name(std::move(rhs.name)), ptr(std::move(rhs.ptr)) {
cout << "Widget(Widget&& rhs) used for object@" << this
<< " addr_name: " << &(this->name) <<" string buffer addr: "<<static_cast<const void*>(this->name.data())<< endl;
}

//针对万能引用使用std::forward。
//注意,这里使用万能引用来替代两个重载版本:void setName(const
// string&)和void setName(string&&)
//好处就是当使用字符串字面量时,万能引用版本的效率更高。如w.setName("SantaClaus"),此时字符串会被
//推导为const
// char(&)[11]类型,然后直接转给setName函数(可以避免先通过字量面构造临时string对象)。
//并将该类型直接转给name的构造函数,节省了一个构造和释放临时对象的开销,效率更高。
template <typename T> void setName(T &&newName) {
if (newName != name) { //第1次使用newName
name = std::forward<T>(
newName); //针对万能引用的最后一次使用实施forward
}
}
ostream &print_addr_of_name(ostream &os) {
cout << "addr of name: " << static_cast<const void*>(this->name.data()) << endl;
return os;
}
};

// 2. 按值返回函数
// 2.1 按值返回的是一个绑定到右值引用的对象
class Complex {
double x;
double y;

public:
Complex(double x = 0, double y = 0) : x(x), y(y) {}
Complex &operator+=(const Complex &rhs) {
x += rhs.x;
y += rhs.y;
return *this;
}
};

Complex operator+(Complex &&lhs, const Complex &rhs) //重载全局operator+
{
lhs += rhs;
return std::move(lhs); //由于lhs绑定到一个右值引用,这里可以移动到返回值上。
}

// 2.2 按值返回一个绑定到万能引用的对象
template <typename T> auto test(T &&t) {
return std::forward<T>(
t); //由于t是一个万能引用对象。按值返回时实施std::forward
//如果原对象一是个右值,则被移动到返回值上。如果原对象
//是个左值,则会被拷贝到返回值上。
}

// 3. RVO优化
// 3.1 返回局部对象
Widget makeWidget() {
Widget w;
return w; //返回局部对象,满足RVO优化两个条件。为避免复制,会直接在返回值内存上创建w对象。
//但如果改成return
// std::move(w)时,由于返回值类型不同(Widget右值引用,另一个是Widget)
//会剥夺RVO优化的机会,就会先创建w局部对象,再移动给返回值,无形中增加一个移动操作。
//对于这种满足RVO条件的,当某些情况下无法避免复制的(如多路返回),编译器仍会默认地对
//将w转为右值,即return std::move(w),而无须用户显式std::move!!!
}

// 3.2 按值形参作为返回值
Widget makeWidget(Widget w) //注意,形参w是按值传参的。
{
return w; //这里虽然不满足RVO条件(w是形参,不是函数内的局部对象),但仍然会被编译器优化。
//这里会默认地转换为右值,即return std::move(w)
}

int main() {
cout << "1. 针对右值引用实施std::move,针对万能引用实施std::forward" << endl;
Widget w;
w.setName("SantaClaus");
cout << "w_addr:" << &w << endl;
w.print_addr_of_name(cout);

cout << "2. 按值返回时" << endl;
auto t1 = test(w);
auto t2 = test(std::move(w));
cout << "t1_addr:" << &t1 << endl;
t1.print_addr_of_name(cout);

cout << "t2_addr:" << &t2 << endl;
t2.print_addr_of_name(cout);

cout << "3. RVO优化" << endl;

Widget w1 = makeWidget(); //按值返回 局部对象(RVO)
cout << "w1_addr:" << &w1 << endl;
w1.print_addr_of_name(cout);

cout << "w2:\n";
Widget w2 = makeWidget(w1); //按值返回 按值形参对象

cout << "w2_addr:" << &w2 << endl;
w2.print_addr_of_name(cout);

return 0;
}

打印结果:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
./main
1. 针对右值引用实施std::move,针对万能引用实施std::forward
Widget() used for object@0x16dd46df0 addr_name: 0x16dd46df0 string buffer addr: 0x16dd46df0
w_addr:0x16dd46df0
addr of name: 0x16dd46df0
2. 按值返回时
Widget(const Widget& w) used for object@0x16dd46db8 addr_name: 0x16dd46db8 string buffer addr: 0x16dd46db8
Widget(Widget&& rhs) used for object@0x16dd46d90 addr_name: 0x16dd46d90 string buffer addr: 0x16dd46d90
t1_addr:0x16dd46db8
addr of name: 0x16dd46db8
t2_addr:0x16dd46d90
addr of name: 0x16dd46d90
3. RVO优化
Widget() used for object@0x16dd46d68 addr_name: 0x16dd46d68 string buffer addr: 0x16dd46d68
w1_addr:0x16dd46d68
addr of name: 0x16dd46d68
w2:
Widget(const Widget& w) used for object@0x16dd46d18 addr_name: 0x16dd46d18 string buffer addr: 0x16dd46d18
Widget(Widget&& rhs) used for object@0x16dd46d40 addr_name: 0x16dd46d40 string buffer addr: 0x16dd46d40
w2_addr:0x16dd46d40
addr of name: 0x16dd46d40

需要注意的是,Widget{}中的:

1
2
3
4
Widget(Widget&& rhs) noexcept: name(std::move(rhs.name)), ptr(std::move(rhs.ptr))
{
cout << "Widget(Widget&& rhs)" << endl;
}

这个函数会利用一个右值对象来构造新的对象,其中name()会调用string 的移动构造函数来创建新的 string 对象,这两个对象的地址是不同的,但是 string 指向的缓冲区也就是字符串存储地址是相同的,这点需要注意

string 的移动构造函数:

1
2
3
MyString(MyString&& other) noexcept : data(other.data) {
other.data = nullptr;
}

但是如果仔细观察,会发现 string.data() 并不会一样,尽管是通过移动构造的,这是因为SSO(小字符串优化)。SSO 的具体阈值取决于 std::string 的实现,通常在 15 到 24 个字符之间。如果字符串长度低于此阈值,字符串内容将存储在对象本身的内部缓冲区中;超过此阈值,则使用动态内存分配。因为事实是,移动构造在某些情况下,并不会比复制构造更高效

当我们将上述示例的字符变长时:

1
2
3
4
5
6
7
8
9
10
11
class Widget {
std::string name = "SantaClausSantaClausSantaClausSantaClausSantaClausSantaClausSantaClausSantaClaus";
...
}
int main() {
...
...
Widget w;
w.setName("SantaClausSantaClausSantaClausSantaClaus");
...
}

编译运行:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
./main
1. 针对右值引用实施std::move,针对万能引用实施std::forward
Widget() used for object@0x16f89adf0 addr_name: 0x16f89adf0 string buffer addr: 0x1286066c0
w_addr:0x16f89adf0
addr of name: 0x1286066c0
2. 按值返回时
Widget(const Widget& w) used for object@0x16f89adb8 addr_name: 0x16f89adb8 string buffer addr: 0x128606720
Widget(Widget&& rhs) used for object@0x16f89ad90 addr_name: 0x16f89ad90 string buffer addr: 0x1286066c0
t1_addr:0x16f89adb8
addr of name: 0x128606720
t2_addr:0x16f89ad90
addr of name: 0x1286066c0
3. RVO优化
Widget() used for object@0x16f89ad68 addr_name: 0x16f89ad68 string buffer addr: 0x128606750
w1_addr:0x16f89ad68
addr of name: 0x128606750
w2:
Widget(const Widget& w) used for object@0x16f89ad18 addr_name: 0x16f89ad18 string buffer addr: 0x1286067b0
Widget(Widget&& rhs) used for object@0x16f89ad40 addr_name: 0x16f89ad40 string buffer addr: 0x1286067b0
w2_addr:0x16f89ad40
addr of name: 0x1286067b0

这里的运行结果,符合所有的预期。

二、完美转发失败的情形

(一)完美转发失败

  1. 完美转发不仅转发对象,还转发其类型、左右值特征以及是否带有const或volation等修饰词。而完美转发的失败,主要源于模板类型推导失败或推导的结果是错误的类型

  2. 实例说明:假设转发的目标函数f,而转发函数为fwd天然就应该是泛型)。函数如下:

1
2
3
4
5
6
7
8
template<typename… Ts>
void fwd(Ts&&… params)
{
f(std::forward<Ts>(params)…);
}

f(expression); //如果本语句执行了某操作
fwd(expression); //而用同一实参调用fwd则会执行不同操作,则称完美转发失败。

(二)五种完美转发失败的情形

1. 使用大括号初始化列表时

  (1)失败原因分析:由于转发函数是个模板函数,而在模板类型推导中,大括号初始**不能自动被推导为std::initializer_list**。

  (2)解决方案:先用auto声明一个局部变量,再将该局部变量传递给转发函数

2. 0和NULL用作空指针时

  (1)失败原因分析:0或NULL以空指针之名传递给模板时,类型推导的结果是整型,而不是所希望的指针类型。

  (2)解决方案:传递nullptr,而非0或NULL

3. 仅声明static const 整型成员变量,而无其定义时。

  (1)失败原因分析:C++中常量一般是进入符号表的,只有对其取地址时才会实际分配内存。 调用 f 函数时,其实参是直接从符号表中取值,此时不会发生问题。但当调用 fwd 时由于其形参是万能引用,而引用本质上是一个可解引用的指针。 因此当传入 fwd 时会要求准备某块内存以供解引用出该变量出来。但因其未定义,也就没有实际的内存空间, 编译时可能失败(取决于编译器和链接器的实现)。

  (2)解决方案:在类外定义该成员变量。注意这声变量在声明时一般会先给初始值。因此定义时无需也不能再重复指定初始值。

4. 使用重载函数名或模板函数名时

  (1)失败原因分析:由于 fwd 是个模板函数,其形参没有任何关于类型的信息。当传入重载函数名或模板函数(代表许许多多的函数)时,就会导致 fwd 的形参不知绑定到哪个函数上。

  (2)解决方案:在调用fwd调用时手动为形参指定类型信息

5. 转发位域时

  (1)失败原因分析:位域是由机器字的若干任意部分组成的(如32位int的第3至5个比特),但这样的实体是无法直接取地址的。而fwd的形参是个引用,本质上就是指针,所以也没有办法创建指向任意比特的指针。

  (2)解决方案:制作位域值的副本,并以该副本来调用转发函数。
  
以下例子分别解释了这些情况:

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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
#include <iostream>
#include <vector>

using namespace std;

// 1. 大括号初始化列表
void f(const std::vector<int> &v) {
cout << "void f(const std::vector<int> & v)" << endl;
}

// 2. 0或NULL用作空指针时
void f(int x) { cout << "void f(int x)" << endl; }

// 3. 仅声明static const的整型成员变量而无定义
class Widget {
public:
static const std::size_t MinVals;//仅声明,无定义(因为静态变量需在类外定义!)
};

const std::size_t Widget::MinVals = 10;

// 4. 使用重载函数名或模板函数名
int f(int (*pf)(int)) {
cout << "int f(int(*pf)(int))" << endl;
return 0;
}

int processVal(int value) { return 0; }
int processVal(int value, int priority) { return 0; }

// 5.位域
struct IPv4Header {
std::uint32_t version : 4, IHL : 4, DSCP : 6, ECN : 2, totalLength : 16;
//...
};

template <typename T>
T workOnVal(T param) //函数模板,代表许许多多的函数。
{
return param;
}

//用于测试的转发函数
template <typename... Ts>
void fwd(Ts &&...param) //转发函数
{
f(std::forward<Ts>(param)...); //目标函数
}

int main() {
cout << "-------------------1. 大括号初始化列表---------------------"
<< endl;
// 1.1 用同一实参分别调用f和fwd函数
f({1, 2, 3}); //{1, 2, 3}会被隐式转换为std::vector<int>
// fwd({ 1, 2, 3 });
// //编译失败。由于fwd是个函数模板,而模板推导时{}不能自动被推导为std:;initializer_list<T>
// 1.2 解决方案
auto il = {1, 2, 3};
fwd(il);

cout << "-------------------2. 0或NULL用作空指针-------------------"
<< endl;
// 2.1 用同一实参分别调用f和fwd函数
// f(NULL); //调用void f(int)函数,
fwd(NULL); // NULL被推导为int,仍调用void f(int)函数
// 2.2 解决方案:使用nullptr
f(nullptr); //匹配int f(int(*pf)(int))
fwd(nullptr);

cout << "-------3. 仅声明static const的整型成员变量而无定义--------"
<< endl;
// 3.1 用同一实参分别调用f和fwd函数
f(Widget::MinVals); //调用void f(int)函数。实参从符号表中取得,编译成功!
fwd(Widget::
MinVals); // fwd的形参是引用,而引用的本质是指针,但fwd使用到该实参时需要解引用
//这里会因没有为MinVals分配内存而出现编译失败(取决于编译器和链接器)
// 3.2 解决方案:在类外定义该变量

cout << "-------------4. 使用重载函数名或模板函数名---------------" << endl;
// 4.1 用同一实参分别调用f和fwd函数
f(processVal); // ok,由于f形参为int(*pf)(int),带有类型信息,会匹配int
// processVal(int value)
// fwd(processVal);
// //error,fwd的形参不带任何类型信息,不知该匹配哪个processVals重载函数。
// fwd(workOnVal);
// //error,workOnVal是个函数模板,代表许许多多的函数。这里不知绑定到哪个函数
// 4.2 解决方案:手动指定类型信息
using ProcessFuncType = int (*)(int);
ProcessFuncType processValPtr = processVal;
fwd(processValPtr);
fwd(static_cast<ProcessFuncType>(workOnVal)); //调用int f(int(*pf)(int))

cout << "----------------------5. 转发位域时---------------------" << endl;
// 5.1 用同一实参分别调用f和fwd函数
IPv4Header ip = {};
f(ip.totalLength); //调用void f(int)
// fwd(ip.totalLength);
// //error,fwd形参是引用,由于位域是比特位组成。无法创建比特位的引用!
//解决方案:创建位域的副本,并传给fwd
auto length = static_cast<std::uint16_t>(ip.totalLength);
fwd(length);

return 0;
}

运行结果:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
./main
-------------------1. 大括号初始化列表---------------------
void f(const std::vector<int> & v)
void f(const std::vector<int> & v)
-------------------2. 0或NULL用作空指针-------------------
void f(int x)
int f(int(*pf)(int))
int f(int(*pf)(int))
-------3. 仅声明static const的整型成员变量而无定义--------
void f(int x)
void f(int x)
-------------4. 使用重载函数名或模板函数名---------------
int f(int(*pf)(int))
int f(int(*pf)(int))
int f(int(*pf)(int))
----------------------5. 转发位域时---------------------
void f(int x)
void f(int x)

这样修改后,就可以实现完美转发了。

三、参考

这里


C++:完美转发(二)(std::forward)
http://blog.luliang.online/2024/05/12/C++:完美转发(二)(std!forward)/
作者
Luyoung
发布于
2024年5月12日
许可协议