恶搞一下std::forward函数

发表于 | 更新于 | 分类于 |
热度 ℃   |   字数统计: 2,448(字)   |   阅读时长: 12(分) |

前言

关于 std::forward 的用法在之前的文章 《C++11中std::move和std::forward到底干了啥》已经总结过了，它被称为完美转发函数，用于函数模板中完成参数转发任务，当形参为左值引用时把它转发成左值，而在形参成为右值引用时把它转发成右值，依靠了引用折叠规则和 std::remove_reference 模板。

前段时间看到std::forward的源代码时突然有发现有些疑问，后来弄明白了决定换个花样试一试，不过在“恶搞”这个函数之前，先来看一看使用模板的规则，我们以模板函数为例，看看模板是怎么用的。

函数模板

1
2
3
4
5
template<class T>
T Add(T a, T b)
{
    return a + b;
}

这是一个非常简单的模板函数，直接传入参数就可以调用这个函数做加法运算，就像下面这样：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <iostream>

template<class T>
T Add(T a, T b)
{
    return a + b;
}

int main(void)
{
    std::cout << Add(2020, 2) << std::endl;
    std::cout << Add(3.0, 2.1) << std::endl;
    std::cout << Add(std::string("happy"), std::string(" holiday")) << std::endl;

    return 0;
}

函数的运行结果如下：

2022
5.1
happyholiday

我们在调用模板函数时虽然没有指定模板 T 的类型，但是编译器会自动推导，分别生成以下三个函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
int Add(int a, int b)
{
    return a + b;
}

double Add(double a, double b)
{
    return a + b;
}

std::string Add(std::string a, std::string b)
{
    return a + b;
}

但是当我们采用以下的方式调用函数的时候就会出现编译错误

1
std::cout << Add(3, 2.1) << std::endl;
1
2
3
4
5
6
7
8
9
10
11
12
albert@home-pc:/mnt/d/data/cpp/testtemplate$ g++ testt.cpp --std=c++11
testt.cpp: In function ‘int main()’:
testt.cpp:13:28: error: no matching function for call to ‘Add(int, double)’
     std::cout << Add(3, 2.1) << std::endl;
                            ^
testt.cpp:5:3: note: candidate: template<class T> T Add(T, T)
 T Add(T a, T b)
   ^
testt.cpp:5:3: note:   template argument deduction/substitution failed:
testt.cpp:13:28: note:   deduced conflicting types for parameter ‘T’ (‘int’ and ‘double’)
     std::cout << Add(3, 2.1) << std::endl;
                            ^

编译器给出的错误很明显，那就是没有匹配 Add(int, double) 的函数生成，这个模板只提供了一个类型参数，遇到这种情况应该怎么办呢？我们知道 int 可以隐式转换成 double 类型，那就让它默认生成一个类型为 double 的模板函数 Add(int, double) 就可以了，所以这种情况下把调用函数写成下面这样就可以成功编译了：

1
std::cout << Add<double>(3, 2.1) << std::endl;

通过这个例子我们发现有些情况下，这个模板函数的参数类型必须显式传递，接下来我们再来熟悉一下 std::forward 函数。

forwawrd 函数定义

先来复习一下函数的定义：

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
/**
 *  @brief  Forward an lvalue.
 *  @return The parameter cast to the specified type.
 *
 *  This function is used to implement "perfect forwarding".
 */
template<typename _Tp>
  constexpr _Tp&&
  forward(typename std::remove_reference<_Tp>::type& __t) noexcept
  { return static_cast<_Tp&&>(__t); }

/**
 *  @brief  Forward an rvalue.
 *  @return The parameter cast to the specified type.
 *
 *  This function is used to implement "perfect forwarding".
 */
template<typename _Tp>
  constexpr _Tp&&
  forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
  {
    static_assert(!std::is_lvalue_reference<_Tp>::value, "template argument"
          " substituting _Tp is an lvalue reference type");
    return static_cast<_Tp&&>(__t);
  }

以上两个模板函数就是用来实现完美转发左值引用和右值引用的，那么你可以试试，当调用第一个函数的时候能不能推导出 _Tp 是什么类型，我之前的疑惑也在这里，这个函数的参数 typename std::remove_reference<_Tp>::type& __t 和模板参数类型 _Tp 看起来关系很密切，但好像又没关系，因为虽然知道参数类型 typename std::remove_reference<_Tp>::type& __t 是个左值引用，但是你并不知道 _Tp 是什么类型，它还是需要显式来指定的，我们接下来试一试和我们想的一不一样。

forwawrd 完美转发

直接拿一个之前写过的完美转发例子吧，代码如下：

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
#include <iostream>
#include <utility>

void Print(int& val)
{
    std::cout << "lvalue refrence: val=" << val << std::endl;
}

void Print(int&& val)
{
    std::cout << "rvalue refrence: val=" << val << std::endl;
}

template<typename T>
void TPrint(T&& t)
{
    return Print(std::forward<T>(t));
}

int main()
{
    int date = 2022;
    TPrint(date);
    TPrint(501);

    return 0;
}

编译运行之后的结果如下：

1
2
3
4
albert@home-pc:/mnt/d/data/cpp/testtemplate$ g++ testf.cpp --std=c++11
albert@home-pc:/mnt/d/data/cpp/testtemplate$ ./a.out
lvalue refrence: val=2022
rvalue refrence: val=501

通过结果我们发现 std::forward 函数在拥有万能引用参数的模板函数中实现了完美转发，左值转发后调用了参数为左值引用的函数，右值转发后调用了参数为右值引用的函数，这时如果我们把调用 std::forward 的地方改一下，去掉指定的参数类型 T，写成 return Print(std::forward(t));，然后编译看看会发生什么

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
albert@home-pc:/mnt/d/data/cpp/testtemplate$ g++ testf.cpp --std=c++11
testf.cpp: In instantiation of ‘void TPrint(T&&) [with T = int&]’:
testf.cpp:23:16:   required from here
testf.cpp:17:30: error: no matching function for call to ‘forward(int&)’
     return Print(std::forward(t));
                              ^
In file included from /usr/include/c++/5/bits/stl_pair.h:59:0,
                 from /usr/include/c++/5/bits/stl_algobase.h:64,
                 from /usr/include/c++/5/bits/char_traits.h:39,
                 from /usr/include/c++/5/ios:40,
                 from /usr/include/c++/5/ostream:38,
                 from /usr/include/c++/5/iostream:39,
                 from testf.cpp:1:
/usr/include/c++/5/bits/move.h:76:5: note: candidate: template<class _Tp> constexpr _Tp&& std::forward(typename std::remove_reference<_From>::type&)
     forward(typename std::remove_reference<_Tp>::type& __t) noexcept
     ^
/usr/include/c++/5/bits/move.h:76:5: note:   template argument deduction/substitution failed:
testf.cpp:17:30: note:   couldn't deduce template parameter ‘_Tp’
     return Print(std::forward(t));
                              ^
In file included from /usr/include/c++/5/bits/stl_pair.h:59:0,
                 from /usr/include/c++/5/bits/stl_algobase.h:64,
                 from /usr/include/c++/5/bits/char_traits.h:39,
                 from /usr/include/c++/5/ios:40,
                 from /usr/include/c++/5/ostream:38,
                 from /usr/include/c++/5/iostream:39,
                 from testf.cpp:1:
/usr/include/c++/5/bits/move.h:87:5: note: candidate: template<class _Tp> constexpr _Tp&& std::forward(typename std::remove_reference<_From>::type&&)
     forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
     ^
/usr/include/c++/5/bits/move.h:87:5: note:   template argument deduction/substitution failed:
testf.cpp:17:30: note:   couldn't deduce template parameter ‘_Tp’
     return Print(std::forward(t));
                              ^
testf.cpp:17:33: error: return-statement with a value, in function returning 'void' [-fpermissive]
     return Print(std::forward(t));
                                 ^
testf.cpp: In instantiation of ‘void TPrint(T&&) [with T = int]’:
testf.cpp:24:15:   required from here
testf.cpp:17:30: error: no matching function for call to ‘forward(int&)’
     return Print(std::forward(t));
                              ^
In file included from /usr/include/c++/5/bits/stl_pair.h:59:0,
                 from /usr/include/c++/5/bits/stl_algobase.h:64,
                 from /usr/include/c++/5/bits/char_traits.h:39,
                 from /usr/include/c++/5/ios:40,
                 from /usr/include/c++/5/ostream:38,
                 from /usr/include/c++/5/iostream:39,
                 from testf.cpp:1:
/usr/include/c++/5/bits/move.h:76:5: note: candidate: template<class _Tp> constexpr _Tp&& std::forward(typename std::remove_reference<_From>::type&)
     forward(typename std::remove_reference<_Tp>::type& __t) noexcept
     ^
/usr/include/c++/5/bits/move.h:76:5: note:   template argument deduction/substitution failed:
testf.cpp:17:30: note:   couldn't deduce template parameter ‘_Tp’
     return Print(std::forward(t));
                              ^
In file included from /usr/include/c++/5/bits/stl_pair.h:59:0,
                 from /usr/include/c++/5/bits/stl_algobase.h:64,
                 from /usr/include/c++/5/bits/char_traits.h:39,
                 from /usr/include/c++/5/ios:40,
                 from /usr/include/c++/5/ostream:38,
                 from /usr/include/c++/5/iostream:39,
                 from testf.cpp:1:
/usr/include/c++/5/bits/move.h:87:5: note: candidate: template<class _Tp> constexpr _Tp&& std::forward(typename std::remove_reference<_From>::type&&)
     forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
     ^
/usr/include/c++/5/bits/move.h:87:5: note:   template argument deduction/substitution failed:
testf.cpp:17:30: note:   couldn't deduce template parameter ‘_Tp’
     return Print(std::forward(t));
                              ^
testf.cpp:17:33: error: return-statement with a value, in function returning 'void' [-fpermissive]
     return Print(std::forward(t));

这次出了一个很长的编译错误，看来还是需要指定类型的，既然是需要指定的，那我们指定成其他的有没有问题呢？比如写成下面这样：

1
return Print(std::forward<float>(t));

编译运行结果如下，都变成了右值引用：

1
2
3
4
albert@home-pc:/mnt/d/data/cpp/testtemplate$ g++ testf.cpp --std=c++11
albert@home-pc:/mnt/d/data/cpp/testtemplate$ ./a.out
rvalue refrence: val=2022
rvalue refrence: val=501

再改成下面这样：

1
return Print(std::forward<T&>(t));

编译运行结果如下，都变成了左值引用：

1
2
3
4
albert@home-pc:/mnt/d/data/cpp/testtemplate$ g++ testf.cpp --std=c++11
albert@home-pc:/mnt/d/data/cpp/testtemplate$ ./a.out
lvalue refrence: val=2022
lvalue refrence: val=501

完美转发失效

上面的这两个例子能说明完美转发失效了吗？这倒也不能说明，第一个例子全都转发成了右值引用，第二个例子全部转发成了左值引用，和我们指定的类型是一致的，也算实现了完美转发，只不过通过这些例子更加深入的理解了完美转发的含义，就是能保证转化成指定的类型，如果指定的类型是个万能引用，就会根据原始类型来完成转发，本次探索之旅到此也就结束了，解答疑惑是个有趣的事情。

总结

  • std::forward 的本质还是进行强制类型转换，它会把传入的参数转发成指定的类型
  • 完美转发其实是可以脱离左值右值概念的，这也是对完美转发更加深入的理解吧
==>> 反爬链接，请勿点击，原地爆炸，概不负责！<<==

每一点付出终有回报，每一滴汗水从不会白流，可能你看不见也摸不着，但其实它已经悄然声息的改变了你，改变了你周围的点点滴滴~

2022-5-1 22:58:21

Albert Shi wechat
欢迎您扫一扫上面的微信公众号，订阅我的博客