引用传参与reference_wrapper

2020-04-21 16:00:47来源:博客园 阅读 ()

新老客户大回馈,云服务器低至5折

引用传参与reference_wrapper

本文是<functional>系列的第3篇。

引用传参

我有一个函数:

void modify(int& i)
{
    ++i;
}

因为参数类型是int&,所以函数能够修改传入的整数,而非其拷贝。

然后我用std::bind把它和一个int绑定起来:

int i = 1;
auto f = std::bind(modify, i);
f();
std::cout << i << std::endl;

可是i还是1,为什么呢?原来std::bind会把所有参数都拷贝,即使它是个左值引用。所以modify中修改的变量,实际上是std::bind返回的函数对象中的一个int,并非原来的i

我们需要std::reference_wrapper

int j = 1;
auto g = std::bind(modify, std::ref(j));
g();
std::cout << j << std::endl;

std::ref(j)返回的就是std::reference_wrapper<int>对象。

reference_wrapper

std::reference_wrapper及其辅助函数大致长成这样:

template<typename T>
class reference_wrapper
{
public:
    template<typename U>
    reference_wrapper(U&& x) : ptr(std::addressof(x)) { }
    
    reference_wrapper(const reference_wrapper&) noexcept = default;
    reference_wrapper& operator=(const reference_wrapper& x) noexcept = default;
 
    constexpr operator T& () const noexcept { return *ptr; }
    constexpr T& get() const noexcept { return *ptr; }
 
    template<typename... Args>
    auto operator()(Args&&... args) const
    {
        return get()(std::forward<Args>(args)...);
    }
    
private:
    T* ptr;
};

template<typename T>
reference_wrapper<T> ref(T& t) noexcept
{
    return reference_wrapper<T>(t);
}
template<typename T>
reference_wrapper<T> ref(reference_wrapper<T> t) noexcept
{
    return t;
}
template<typename T>
void ref(const T&&) = delete;

template<typename T>
reference_wrapper<const T> cref(const T& t) noexcept
{
    return reference_wrapper<const T>(t);
}
template<typename T>
reference_wrapper<const T> cref(reference_wrapper<T> t) noexcept
{
    return reference_wrapper<const T>(t.get());
}
template<typename T>
void cref(const T&&) = delete;

可见,std::reference_wrapper不过是包装一个指针罢了。它重载了operator T&,对象可以隐式转换回原来的引用;它还重载了operator(),包装函数对象时可以直接使用函数调用运算符;调用其他成员函数时,要先用get方法获得其内部的引用。

std::reference_wrapper的意义在于:

  1. 引用不是对象,不存在引用的引用、引用的数组等,但std::reference_wrapper是,使得定义引用的容器成为可能;

  2. 模板函数无法辨别你在传入左值引用时的意图是传值还是传引用,std::refstd::cref告诉那个模板,你要传的是引用。

实现

尽管std::reference_wrapper的简单(但是不完整的)实现可以在50行以内完成,GCC的标准库为了实现一个完美的std::reference_wrapper还是花了300多行(还不包括std::invoke),其中200多行是为了定义result_typeargument_typefirst_argument_typesecond_argument_type这几个在C++17中废弃、C++20中移除的成员类型。如果你是在C++20完全普及以后读到这篇文章的,就当考古来看吧!

继承成员类型

定义这些类型所用的工具是继承,一种特殊的、没有“is-a”含义的public继承。以_Maybe_unary_or_binary_function为例:

template<typename _Arg, typename _Result>
  struct unary_function
  {
    typedef _Arg      argument_type;   
    typedef _Result   result_type;  
  };

template<typename _Arg1, typename _Arg2, typename _Result>
  struct binary_function
  {
    typedef _Arg1     first_argument_type; 
    typedef _Arg2     second_argument_type;
    typedef _Result   result_type;
  };

template<typename _Res, typename... _ArgTypes>
  struct _Maybe_unary_or_binary_function { };

template<typename _Res, typename _T1>
  struct _Maybe_unary_or_binary_function<_Res, _T1>
  : std::unary_function<_T1, _Res> { };

template<typename _Res, typename _T1, typename _T2>
  struct _Maybe_unary_or_binary_function<_Res, _T1, _T2>
  : std::binary_function<_T1, _T2, _Res> { };

然后std::function<Res(Args...)>去继承_Maybe_unary_or_binary_function<Res, Args...>:当sizeof...(Args) == 1时继承到std::unary_function,定义argument_type;当sizeof...(Args) == 2时继承到std::binary_function,定义first_argument_typesecond_argument_type;否则继承一个空的_Maybe_unary_or_binary_function,什么定义都没有。

各种模板技巧,tag dispatching、SFINAE等,面对这种需求都束手无策,只有继承管用。

成员函数特征

template<typename _Signature>
  struct _Mem_fn_traits;

template<typename _Res, typename _Class, typename... _ArgTypes>
  struct _Mem_fn_traits_base
  {
    using __result_type = _Res;
    using __maybe_type
      = _Maybe_unary_or_binary_function<_Res, _Class*, _ArgTypes...>;
    using __arity = integral_constant<size_t, sizeof...(_ArgTypes)>;
  };

#define _GLIBCXX_MEM_FN_TRAITS2(_CV, _REF, _LVAL, _RVAL)                \
  template<typename _Res, typename _Class, typename... _ArgTypes>       \
    struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) _CV _REF>      \
    : _Mem_fn_traits_base<_Res, _CV _Class, _ArgTypes...>               \
    {                                                                   \
      using __vararg = false_type;                                      \
    };                                                                  \
  template<typename _Res, typename _Class, typename... _ArgTypes>       \
    struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) _CV _REF>  \
    : _Mem_fn_traits_base<_Res, _CV _Class, _ArgTypes...>               \
    {                                                                   \
      using __vararg = true_type;                                       \
    };

#define _GLIBCXX_MEM_FN_TRAITS(_REF, _LVAL, _RVAL)              \
  _GLIBCXX_MEM_FN_TRAITS2(              , _REF, _LVAL, _RVAL)   \
  _GLIBCXX_MEM_FN_TRAITS2(const         , _REF, _LVAL, _RVAL)   \
  _GLIBCXX_MEM_FN_TRAITS2(volatile      , _REF, _LVAL, _RVAL)   \
  _GLIBCXX_MEM_FN_TRAITS2(const volatile, _REF, _LVAL, _RVAL)

_GLIBCXX_MEM_FN_TRAITS( , true_type, true_type)
_GLIBCXX_MEM_FN_TRAITS(&, true_type, false_type)
_GLIBCXX_MEM_FN_TRAITS(&&, false_type, true_type)

#if __cplusplus > 201402L
_GLIBCXX_MEM_FN_TRAITS(noexcept, true_type, true_type)
_GLIBCXX_MEM_FN_TRAITS(& noexcept, true_type, false_type)
_GLIBCXX_MEM_FN_TRAITS(&& noexcept, false_type, true_type)
#endif

#undef _GLIBCXX_MEM_FN_TRAITS
#undef _GLIBCXX_MEM_FN_TRAITS2

_Mem_fn_traits是成员函数类型的特征(trait)类型,定义了__result_type__maybe_type__arity__vararg成员类型:__arity表示元数,__vararg指示成员函数类型是否是可变参数的(如std::printf,非变参模板)。... ...中的前三个点表示变参模板,后三个点表示可变参数,参考:What are the 6 dots in template parameter packs?

成员函数类型有constvolatile&/&&noexcept(C++17开始noexcept成为函数类型的一部分)4个维度,共24种,单独定义太麻烦,所以用了宏。

检测成员类型

一个类模板,当模板参数的类型定义了成员类型result_type时该类模板也定义它,否则不定义它,如何实现?我刚刚新学到一种方法,用void_t(即__void_t)。

void_t的定义出奇地简单:

template<typename...>
using void_t = void;

不就是一个void嘛,有什么用呢?请看:

template<typename _Functor, typename = __void_t<>>
  struct _Maybe_get_result_type
  { };

template<typename _Functor>
  struct _Maybe_get_result_type<_Functor,
                                __void_t<typename _Functor::result_type>>
  { typedef typename _Functor::result_type result_type; };

第二个定义是第一个定义的特化。当_Functor类型定义了result_type时,两个都正确,但是第二个更加特化,匹配到第二个,传播result_type;反之,第二个在实例化过程中发生错误,根据SFINAE,匹配到第一个,不定义result_type

void_t的技巧,本质上还是SFINAE。

以下两个类同理:

template<typename _Tp, typename = __void_t<>>
  struct _Refwrap_base_arg1
  { };

template<typename _Tp>
  struct _Refwrap_base_arg1<_Tp,
                            __void_t<typename _Tp::argument_type>>
  {
    typedef typename _Tp::argument_type argument_type;
  };

template<typename _Tp, typename = __void_t<>>
  struct _Refwrap_base_arg2
  { };

template<typename _Tp>
  struct _Refwrap_base_arg2<_Tp,
                            __void_t<typename _Tp::first_argument_type,
                                     typename _Tp::second_argument_type>>
  {
    typedef typename _Tp::first_argument_type first_argument_type;
    typedef typename _Tp::second_argument_type second_argument_type;
  };

分类讨论

#if __cpp_noexcept_function_type
#define _GLIBCXX_NOEXCEPT_PARM , bool _NE
#define _GLIBCXX_NOEXCEPT_QUAL noexcept (_NE)
#else
#define _GLIBCXX_NOEXCEPT_PARM
#define _GLIBCXX_NOEXCEPT_QUAL
#endif

/**
 *  Base class for any function object that has a weak result type, as
 *  defined in 20.8.2 [func.require] of C++11.
*/
template<typename _Functor>
  struct _Weak_result_type_impl
  : _Maybe_get_result_type<_Functor>
  { };

/// Retrieve the result type for a function type.
template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM>
  struct _Weak_result_type_impl<_Res(_ArgTypes...) _GLIBCXX_NOEXCEPT_QUAL>
  { typedef _Res result_type; };

/// Retrieve the result type for a varargs function type.
template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM>
  struct _Weak_result_type_impl<_Res(_ArgTypes......) _GLIBCXX_NOEXCEPT_QUAL>
  { typedef _Res result_type; };

/// Retrieve the result type for a function pointer.
template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM>
  struct _Weak_result_type_impl<_Res(*)(_ArgTypes...) _GLIBCXX_NOEXCEPT_QUAL>
  { typedef _Res result_type; };

/// Retrieve the result type for a varargs function pointer.
template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM>
  struct
  _Weak_result_type_impl<_Res(*)(_ArgTypes......) _GLIBCXX_NOEXCEPT_QUAL>
  { typedef _Res result_type; };

// Let _Weak_result_type_impl perform the real work.
template<typename _Functor,
         bool = is_member_function_pointer<_Functor>::value>
  struct _Weak_result_type_memfun
  : _Weak_result_type_impl<_Functor>
  { };

// A pointer to member function has a weak result type.
template<typename _MemFunPtr>
  struct _Weak_result_type_memfun<_MemFunPtr, true>
  {
    using result_type = typename _Mem_fn_traits<_MemFunPtr>::__result_type;
  };

// A pointer to data member doesn't have a weak result type.
template<typename _Func, typename _Class>
  struct _Weak_result_type_memfun<_Func _Class::*, false>
  { };

/**
 *  Strip top-level cv-qualifiers from the function object and let
 *  _Weak_result_type_memfun perform the real work.
*/
template<typename _Functor>
  struct _Weak_result_type
  : _Weak_result_type_memfun<typename remove_cv<_Functor>::type>
  { };

/**
 *  Derives from unary_function or binary_function when it
 *  can. Specializations handle all of the easy cases. The primary
 *  template determines what to do with a class type, which may
 *  derive from both unary_function and binary_function.
*/
template<typename _Tp>
  struct _Reference_wrapper_base
  : _Weak_result_type<_Tp>, _Refwrap_base_arg1<_Tp>, _Refwrap_base_arg2<_Tp>
  { };

// - a function type (unary)
template<typename _Res, typename _T1 _GLIBCXX_NOEXCEPT_PARM>
  struct _Reference_wrapper_base<_Res(_T1) _GLIBCXX_NOEXCEPT_QUAL>
  : 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 _GLIBCXX_NOEXCEPT_PARM>
  struct _Reference_wrapper_base<_Res(_T1, _T2) _GLIBCXX_NOEXCEPT_QUAL>
  : 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>
  { };

// - a function pointer type (unary)
template<typename _Res, typename _T1 _GLIBCXX_NOEXCEPT_PARM>
  struct _Reference_wrapper_base<_Res(*)(_T1) _GLIBCXX_NOEXCEPT_QUAL>
  : unary_function<_T1, _Res>
  { };

// - a function pointer type (binary)
template<typename _Res, typename _T1, typename _T2 _GLIBCXX_NOEXCEPT_PARM>
  struct _Reference_wrapper_base<_Res(*)(_T1, _T2) _GLIBCXX_NOEXCEPT_QUAL>
  : binary_function<_T1, _T2, _Res>
  { };

template<typename _Tp, bool = is_member_function_pointer<_Tp>::value>
  struct _Reference_wrapper_base_memfun
  : _Reference_wrapper_base<_Tp>
  { };

template<typename _MemFunPtr>
  struct _Reference_wrapper_base_memfun<_MemFunPtr, true>
  : _Mem_fn_traits<_MemFunPtr>::__maybe_type
  {
    using result_type = typename _Mem_fn_traits<_MemFunPtr>::__result_type;
  };

不说了,看图:

我的感受:

大功告成

template<typename _Tp>
  class reference_wrapper
  : public _Reference_wrapper_base_memfun<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&) = default;

    reference_wrapper&
    operator=(const reference_wrapper&) = default;

    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 std::__invoke(get(), std::forward<_Args>(__args)...);
      }
  };

template<typename _Tp>
  inline reference_wrapper<_Tp>
  ref(_Tp& __t) noexcept
  { return reference_wrapper<_Tp>(__t); }

template<typename _Tp>
  inline reference_wrapper<const _Tp>
  cref(const _Tp& __t) noexcept
  { return reference_wrapper<const _Tp>(__t); }

template<typename _Tp>
  void ref(const _Tp&&) = delete;

template<typename _Tp>
  void cref(const _Tp&&) = delete;

template<typename _Tp>
  inline reference_wrapper<_Tp>
  ref(reference_wrapper<_Tp> __t) noexcept
  { return __t; }

template<typename _Tp>
  inline reference_wrapper<const _Tp>
  cref(reference_wrapper<_Tp> __t) noexcept
  { return { __t.get() }; }

最后组装一下就好啦!


原文链接:https://www.cnblogs.com/jerry-fuyi/p/12747850.html
如有疑问请与原作者联系

标签:

版权申明:本站文章部分自网络,如有侵权,请联系:west999com@outlook.com
特别注意:本站所有转载文章言论不代表本站观点,本站所提供的摄影照片,插画,设计作品,如需使用,请与原作者联系,版权归原作者所有

上一篇:WDK驱动调试问题点滴

下一篇:从Point类继承的Circle类 代码参考