这篇文章给大家分享的是有关C++11中std::ref和std::cref的作用是什么的内容。小编觉得挺实用的，因此分享给大家做个参考，一起跟随小编过来看看吧。
本文是基于gcc-4.9.0的源代码进行分析，std::ref和std::cref是C++11才加入标准的，所以低版本的gcc源码是没有这两个的，建议选择4.9.0或更新的版本去学习，不同版本的gcc源码差异应该不小，但是原理和设计思想的一样的，下面给出源码下载地址
http://ftp.gnu.org/gnu/gcc
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而已）
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的实现
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展现出和普通的引用一样的效果而进行的运算符重载啥的，这里就不赘述了，实现比较简单，大家可以自己看一看具体的代码
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_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;
};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是啥东西就行了
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的作用是什么”这篇文章就分享到这里了，希望以上内容可以对大家有一定的帮助，让大家可以学到更多知识，如果觉得文章不错，可以把它分享出去让更多的人看到吧！
免责声明：本站发布的内容（图片、视频和文字）以原创、转载和分享为主，文章观点不代表本网站立场，如果涉及侵权请联系站长邮箱：is@yisu.com进行举报，并提供相关证据，一经查实，将立刻删除涉嫌侵权内容。
