首页 > 软件编程 > C 语言 > C++11 std::ref std::cref

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

2021-05-11 11:47:09 作者：彼方丶

这篇文章主要介绍了解析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_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中

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 内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！