个人中心
gpt4 book ai didi

解析C++11的std::ref、std::cref源码

转载 作者：qq735679552 更新时间：2022-09-27 22:32:09 25 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章解析C++11的std::ref、std::cref源码由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

1、源码准备

本文是基于gcc-4.9.0的源代码进行分析，std::ref和std::cref是C++11才加入标准的，所以低版本的gcc源码是没有这两个的，建议选择4.9.0或更新的版本去学习，不同版本的gcc源码差异应该不小，但是原理和设计思想的一样的，下面给出源码下载地址 http://ftp.gnu.org/gnu/gcc 。

2、std::ref和std::cref的作用

C++本身就有引用（&），那为什么C++11又引入了std::ref（或者std::cref）呢？ 主要是考虑函数式编程（如std::bind）在使用时，是对参数直接拷贝，而不是引用。下面是一个简单的例子:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <functional>
#include <iostream>
void fun( int & n1, int & n2, const int & n3)
{
     std::cout << "In function: " << n1 << ' ' << n2 << ' ' << n3 << '\n' ;
     ++n1; // increments the copy of n1 stored in the function object
     ++n2; // increments the main()'s n2
     // ++n3; // compile error
     std::cout << "In function end: " << n1 << ' ' << n2 << ' ' << n3 << '\n' ;
}
 
int main()
{
     int n1 = 1, n2 = 1, n3 = 1;
     std::function< void ()> fff = std::bind(f, n1, std::ref(n2), std::cref(n3));
     std::cout << "Before function: " << n1 << ' ' << n2 << ' ' << n3 << '\n' ;
     fff();
     std::cout << "After function: " << n1 << ' ' << n2 << ' ' << n3 << '\n' ;
}

运行结果:

Before function: 1 1 1 In function: 1 1 1 In function end: 2 2 1 After function: 1 2 1 。

从上面的例子中可以看到，执行完fff，n1的值仍然是1，n2的值已经改变，这说明std::bind使用的是参数的拷贝而不是引用，这也就是为什么C++11要引入std::ref和std::cref的原因了，接下来分析std::ref的实现（std::cref不作分析，因为和std::ref的位移差别只是引用变成了const而已） 。

3、std::ref相关源码解析

3.1、std::ref解析

std::ref位于libstdc++-v3\include\std\functional中 。

?
1
2
3
4
5
6
7
8
9
10
template < typename _Tp>
inline reference_wrapper<_Tp> ref(_Tp& __t) noexcept
{ return reference_wrapper<_Tp>(__t); }
 
template < typename _Tp>
void ref( const _Tp&&) = delete ;
 
template < typename _Tp>
inline reference_wrapper<_Tp> ref(reference_wrapper<_Tp> __t) noexcept
{ return ref(__t.get()); }

从源代码中可以看出:

  • std::ref是一个模板函数，返回值是模板类std::reference_wrapper
  • 从第二个函数可以看到，std::ref不允许传递右值引用参数，即无法包装右值引用传递的值
  • std::ref的传入参数可以是一个普通的引用，也可以是另外一个std::reference_wrapper对象，接下来分析std::reference_wrapper的实现

3.2、std::reference_wrapper解析

std::reference_wrapper位于libstdc++-v3\include\std\functional中 。

?
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
template < typename _Tp>
class reference_wrapper : public _Reference_wrapper_base< typename remove_cv<_Tp>::type>
{
     _Tp* _M_data;
 
public :
     typedef _Tp type;
 
     reference_wrapper(_Tp& __indata) noexcept
         :_M_data(std::__addressof(__indata))
     {
     }
 
     reference_wrapper(_Tp&&) = delete ;
 
     reference_wrapper( const reference_wrapper<_Tp>& __inref) noexcept
         :_M_data(__inref._M_data)
     {
     }
 
     reference_wrapper& operator=( const reference_wrapper<_Tp>& __inref) noexcept
     {
         _M_data = __inref._M_data;
         return * this ;
     }
 
     operator _Tp&() const noexcept
     { return this ->get(); }
 
     _Tp& get() const noexcept
     { return *_M_data; }
 
     template < typename ... _Args>
     typename result_of<_Tp&(_Args&&...)>::type
     operator()(_Args&&... __args) const
     {
         return __invoke(get(), std::forward<_Args>(__args)...);
     }
};

从源代码中可以获得以下信息:

  • 该类继承于std::_Reference_wrapper_base
  • 有一个类成员_M_data，类型为所引用类型的指针
  • 第一个构造函数通过调用std::__addressof函数，获得了指向引用参数的指针，并赋值给了_M_data（这也是为什么不支持右值引用的原因，因为取不到对应的地址），std::__addressof实现如下：
?
1
2
3
4
5
6
7
8
// 位于**libstdc++-v3\include\bits\move.h**中
// 借助reinterpret_cast能任意转换类型的特性来将<code>_Tp&</code>转为<code>_Tp*</code>
//（转换过程编译器不保证正确，要由程序员来保证转换过程不出错，虽然标准库用了很多这样的特殊技巧，但是实际开发中这些少用为好）
template < typename _Tp>
inline _Tp* __addressof(_Tp& __r) _GLIBCXX_NOEXCEPT
{
     return reinterpret_cast <_Tp*>(& const_cast < char &>( reinterpret_cast < const volatile char &>(__r)));
}
  • 拷贝构造函数和赋值函数就只是简单地将_M_data的值进行传递而已了
  • 其余方法就是为了让std::reference_wrapper展现出和普通的引用一样的效果而进行的运算符重载啥的，这里就不赘述了，实现比较简单，大家可以自己看一看具体的代码

3.3、std::remove_cv解析

std::remove_cv位于libstdc+±v3\include\std\type_traits中 。

分析std::_Reference_wrapper_base之前先看一下std::remove_cv的实现 其实从std::remove_cv存在于type_traits文件这一点就可以大致推断出，std::remove_cv使用了模板元技术，模板元的主要思想为：利用模板特化机制实现编译期条件选择结构，利用递归模板实现编译期循环结构，模板元程序则由编译器在编译器解释运行，但是其也有明显的优缺点，优点是运行时速度极快，缺点是程序很难看懂，容易劝退初学者，这里不对其做深入分析，知道是这样一个东西就行，有兴趣的可以去查阅专业的C++书籍去了解其中的奥秘 源代码如下，作用是将模板_Tp的const和voaltile属性分离，这样的话使用::value就可以得到没有const、volatile的类型了 。

?
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
/// remove_const
template < typename _Tp>
struct remove_const
{ typedef _Tp    type; };
 
template < typename _Tp>
struct remove_const<_Tp const >
{ typedef _Tp    type; };
 
/// remove_volatile
template < typename _Tp>
struct remove_volatile
{ typedef _Tp    type; };
 
template < typename _Tp>
struct remove_volatile<_Tp volatile >
{ typedef _Tp    type; };
 
/// remove_cv
template < typename _Tp>
struct remove_cv
{
   typedef typename
   remove_const< typename remove_volatile<_Tp>::type>::type    type;
};

3.4、std::_Reference_wrapper_base解析

std::_Reference_wrapper_base位于libstdc++-v3\include\std\functional中 。

?
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
template < typename _Tp>
struct _Reference_wrapper_base
     :_Reference_wrapper_base_impl<
      __has_argument_type<_Tp>::value,
      __has_first_argument_type<_Tp>::value
      && __has_second_argument_type<_Tp>::value,
      _Tp>
{};
 
template < typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res(_T1)> : unary_function<_T1, _Res>
{};
 
template < typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res(_T1) const > : unary_function<_T1, _Res>
{};
 
template < typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res(_T1) volatile > : unary_function<_T1, _Res>
{};
 
template < typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res(_T1) const volatile > : unary_function<_T1, _Res>
{};
 
// - a function type (binary)
template < typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res(_T1, _T2)> : binary_function<_T1, _T2, _Res>
{};
 
template < typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res(_T1, _T2) const > : binary_function<_T1, _T2, _Res>
{};
 
template < typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res(_T1, _T2) volatile > : binary_function<_T1, _T2, _Res>
{};
 
template < typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res(_T1, _T2) const volatile > : binary_function<_T1, _T2, _Res>
{};
 
template < typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res(*)(_T1)> : unary_function<_T1, _Res>
{};
 
template < typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res(*)(_T1, _T2)> : binary_function<_T1, _T2, _Res>
{};
 
template < typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res (_T1::*)()> : unary_function<_T1*, _Res>
{};
 
template < typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res (_T1::*)(_T2)> : binary_function<_T1*, _T2, _Res>
{};
 
template < typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res (_T1::*)() const > : unary_function< const _T1*, _Res>
{};
 
template < typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const > : binary_function< const _T1*, _T2, _Res>
{};
 
template < typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res (_T1::*)() volatile > : unary_function< volatile _T1*, _Res>
{};
 
template < typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res (_T1::*)(_T2) volatile > : binary_function< volatile _T1*, _T2, _Res>
{};
 
template < typename _Res, typename _T1>
struct _Reference_wrapper_base<_Res (_T1::*)() const volatile > : unary_function< const volatile _T1*, _Res>
{};
 
template < typename _Res, typename _T1, typename _T2>
struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const volatile > : binary_function< const volatile _T1*, _T2, _Res>
{};

从代码中可以看出，std::_Reference_wrapper_base继承于std::unary_function或者std::binary_function，在实际编程中对std::reference_wrapper的作用不大，除非引用的是一个函数对象，所以在这里就不分析它的具体作用了，大家直接去查一下unary_function和binary_function是啥东西就行了 。

4、总结

std::ref和std::cref在函数式编程中的作用是非常大的，C++11后的源代码中多次使用到了它们。而std::ref和std::cref事实上是模板函数，返回值是一个std::reference_wrapper对象，而std::reference_wrapper虽然是一个对象，可是他却能展现出和普通引用类似的效果，这点和前一篇文章讲的智能指针如出一辙（事实上标准库大多是这样设计的，这也是运算符重载存在的一个重要意义）。当我们在函数式编程（如std::bind）中需要对参数进行引用传递时，只需要用std::ref或std::cref修饰该引用即可 。

到此这篇关于解析C++11的std::ref、std::cref源码的文章就介绍到这了,更多相关C++11 std::ref、std::cref 内容请搜索我以前的文章或继续浏览下面的相关文章希望大家以后多多支持我！ 。

原文链接：https://blog.csdn.net/weixin_43798887/article/details/116562336 。

最后此篇关于解析C++11的std::ref、std::cref源码的文章就讲到这里了,如果你想了解更多关于解析C++11的std::ref、std::cref源码的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

25 4 0
文章推荐： python+opencv 读取文件夹下的所有图像并批量保存ROI的方法
文章推荐： pandas ix loc的区别
文章推荐： 2021年情头520甜蜜又浪漫的卡通情头 520专属的秀恩爱卡通头像
文章推荐： 高级气质有品位的微信女生头像 倚在夏日的清凉处想拥有一段静美的时光
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
全站热门文章
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com