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

2024-04-02 19:04:59 922人浏览八月长安

摘要

目录1、源码准备2、std::ref和std::cref的作用3、std::ref相关源码解析3.1、std::ref解析3.2、std::reference_wrapper解析3.

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

点击免费下载>>软考高级考试备考技巧/历年真题/备考精华资料

--结束END--

本文标题: 解析C++11的std::ref、std::cref源码

本文链接: https://www.lsjlt.com/news/125628.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑，方便收藏和打印～

下载Word文档

去做题

猜你喜欢

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

目录1、源码准备2、std::ref和std::cref的作用3、std::ref相关源码解析3.1、std::ref解析3.2、std::reference_wrapper解析3....

99+

2024-04-02
C++11中std::ref和std::cref的作用是什么

这篇文章给大家分享的是有关C++11中std::ref和std::cref的作用是什么的内容。小编觉得挺实用的，因此分享给大家做个参考，一起跟随小编过来看看吧。1、源码准备本文是基于gcc-4.9.0的源代码进行分析，std::ref和st...

99+

2023-06-15
详解C++11的std::addressof源码解析

目录1、源码准备2、std::addressof简介3、std::addressof源码解析4、总结1、源码准备本文是基于gcc-4.9.0的源代码进行分析，std::addre...

99+

2024-04-02
浅谈C++11的std::mem_fn源码解析

目录1、源码准备2、通过一个简单的例子来了解std::mem_fn的作用3、std::mem_fn源码解析3.1、std::mem_fn解析3.2、std::_Mem_fn解析3.3...

99+

2024-04-02
浅谈C++11的std::function源码解析

目录1、源码准备2、std::function简介3、源码解析3.1、std::function解析3.2、std::_Function_handler解析3.3、_Any_data...

99+

2024-04-02
C++11 中的std::function和std::bind详解

目录1. 可调用对象2. std::function3. std::bind3.1 std::bind绑定普通函数3.2 std::bind绑定一个成员函数3.3 绑定一个引用参数4...

99+

2024-04-02
C++11中std::function与std::bind的用法实例

目录关于std::function 的用法：关于std::bind 的用法：附：std::function与std::bind双剑合璧总结关于std::function 的用法：其...

99+

2024-04-02
c++11中std::move函数的使用

C++11在运行期有所增强，通过增加核心的右值引用机制来改善临时对象导致的效率低下的问题。C++临时对象引入了多余的构造、析构及其内部资源的申请释放函数调用，导致程序运行时性能受损，...

99+

2024-04-02
C++11中std::function基础用法详解

目录一、std::function基本介绍二、进阶使用方法2.1 与智能指针相结合2.2 存储成员函数指针2.3 存储std::bind三、注意tipsstd::function是C...

99+

2023-05-18

C++11 std::function用法 C++11 std::function C++ std::function
C++11的std::future对象如何使用

这篇“C++11的std::future对象如何使用”文章的知识点大部分人都不太理解，所以小编给大家总结了以下内容，内容详细，步骤清晰，具有一定的借鉴价值，希望大家阅读完这篇文章能有所收获，下面我们一起来看看这篇“C++11的std::fu...

99+

2023-07-05
C++ std::function的用法详解

类模版std::function是一种通用、多态的函数封装。std::function的实例可以对任何可以调用的目标实体进行存储、复制、和调用操作，这些目标实体包括普通函数、Lamb...

99+

2024-04-02
C++编程之std::forward使用代码分析

今天小编给大家分享一下C++编程之std::forward使用代码分析的相关知识点，内容详细，逻辑清晰，相信大部分人都还太了解这方面的知识，所以分享这篇文章给大家参考一下，希望大家阅读完这篇文章后有所收获，下面我们一起来了解一下吧。std:...

99+

2023-07-05
C++20中的std::span详解

span就是一个连续对象存储的观察者。类似std::string_view是string的观察者。连续的存储，不一定是数组。例如： zero(char (&arr)...

99+

2023-03-06

C++20 std::span C++ std
深入解析C++中的std::thread的使用

目录std::thread简介一、C++11 线程创建二、std::thread 的构造函数中接收什么参数？三、std::thread 的搭配用法std::thread简介 C++1...

99+

2023-05-16

C++ std::thread使用 C++ std::thread用法 C++ std::thread
C++11之std::future对象的使用以及说明

目录std::future介绍细节说明wait系列操作get操作时序图std::future使用总结std::future介绍在前面几篇文章中基本都用到thread对象，它是C++...

99+

2023-02-28

C++11 std::future std::future对象 std::future对象使用
如何进行c++11中std::move函数的使用

这篇文章给大家介绍如何进行c++11中std::move函数的使用，内容非常详细，感兴趣的小伙伴们可以参考借鉴，希望对大家能有所帮助。C++11在运行期有所增强，通过增加核心的右值引用机制来改善临时对象导致的效率低下的问题。C++临时对象引...

99+

2023-06-29
C++中std::allocator的使用案例详解

标准库中包含一个名为allocator的类，允许我们将分配和初始化分离。使用allocator通常会提供更好的性能和更灵活的内存管理能力。 ...

99+

2024-04-02
C++std::initializer_list实现原理解析及遇到问题

一般而言，对变量或对象使用括号初始化的方式被称为直接初始化，其本质是调用了相应的构造函数；而使用等号初始化的方式则被称为拷贝初始化，说到拷贝大家可能马上就会想到拷贝构造函...

99+

2024-04-02
详解C++语言中std::array的神奇用法

目录概述自动推导数组大小用函数返回std::array编译期字面量数值合法性校验编译期生成数组截取子数组拼接多个数组编译期拼接字符串展望C++20——打破更多的枷锁尾注概述 std:...

99+

2024-04-02
C++STL标准库std::vector的使用详解

目录1. 简介2. 使用示例3. 构造、析构、赋值3.1 std::vector::vector 构造函数3.2 std::vector::~vector 析构函数3.3 std::...

99+

2024-04-02