C++11中std::ref和std::cref的作用是什么

这篇文章给大家分享的是有关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）在使用时，是对参数直接拷贝，而不是引用。下面是一个简单的例子：

#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中

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中

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实现如下：

// 位于**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的类型了

/// remove_consttemplate<typename _Tp>struct remove_const{ typedef _Tp    type; };template<typename _Tp>struct remove_const<_Tp const>{ typedef _Tp    type; };/// remove_volatiletemplate<typename _Tp>struct remove_volatile{ typedef _Tp    type; };template<typename _Tp>struct remove_volatile<_Tp volatile>{ typedef _Tp    type; };/// remove_cvtemplate<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中

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的作用是什么”这篇文章就分享到这里了，希望以上内容可以对大家有一定的帮助，让大家可以学到更多知识，如果觉得文章不错，可以把它分享出去让更多的人看到吧！