引用传参与reference_wrapper
2020-04-21 16:00:47来源:博客园 阅读 ()
引用传参与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
的意义在于:
-
引用不是对象,不存在引用的引用、引用的数组等,但
std::reference_wrapper
是,使得定义引用的容器成为可能; -
模板函数无法辨别你在传入左值引用时的意图是传值还是传引用,
std::ref
和std::cref
告诉那个模板,你要传的是引用。
实现
尽管std::reference_wrapper
的简单(但是不完整的)实现可以在50行以内完成,GCC的标准库为了实现一个完美的std::reference_wrapper
还是花了300多行(还不包括std::invoke
),其中200多行是为了定义result_type
、argument_type
、first_argument_type
和second_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_type
和second_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?
成员函数类型有const
、volatile
、&
/&&
、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驱动调试问题点滴
- 透彻理解C++11新特性:右值引用、std::move、std::forward 2020-04-30
- 模板参数的“右值引用”是转发引用 2020-04-19
- g++链接gcc编译的库报错“undefined reference to xxx” 2020-04-14
- 第一章 从C到C++ 2020-04-04
- C++ non-const lvalue reference cannot bind to a temporar 2020-03-09
IDC资讯: 主机资讯 注册资讯 托管资讯 vps资讯 网站建设
网站运营: 建站经验 策划盈利 搜索优化 网站推广 免费资源
网络编程: Asp.Net编程 Asp编程 Php编程 Xml编程 Access Mssql Mysql 其它
服务器技术: Web服务器 Ftp服务器 Mail服务器 Dns服务器 安全防护
软件技巧: 其它软件 Word Excel Powerpoint Ghost Vista QQ空间 QQ FlashGet 迅雷
网页制作: FrontPages Dreamweaver Javascript css photoshop fireworks Flash