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_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的作用是什么”這篇文章就分享到這里了，希望以上內容可以對大家有一定的幫助，讓大家可以學到更多知識，如果覺得文章不錯，可以把它分享出去讓更多的人看到吧！