成员指针与mem_fn
2020-04-23 16:00:29来源:博客园 阅读 ()
成员指针与mem_fn
本文是<functional>
系列的第4篇。
成员指针是一个非常具有C++特色的功能。更低级的语言(如C)没有类,也就没有成员的概念;更高级的语言(如Java)没有指针,即使有也不会有成员指针这么拗口的东西。
上回在Stack Overflow上看到一个问题,C++是否允许delegate = object.method
这种写法。我猜他是从C#过来的。在C++中,这种写法在语法上是不可能的,语义上可以用std::bind
来实现。而本文的主题std::mem_fn
,则是实现了delegate = method
的功能,object
插到了原来的参数列表的前面,成为新的函数对象的第一个参数。
成员指针
先说说成员指针。成员指针,分为对象成员指针与成员函数指针。下面的程序演示了如何定义和使用它们:
struct Test
{
int object;
void function(int) { }
};
int main()
{
Test test;
Test* ptr = &test;
int Test::* po = &Test::object;
test.*po;
ptr->*po;
void (Test::*pf)(int) = &Test::function;
(test.*pf)(0);
(ptr->*pf)(0);
}
定义为static
的对象或函数,就好像它所在的类不存在一样,只能用普通的指针与函数指针。
这一节的重点在于成员指针的模板匹配。首先,形如对象成员指针的类型可以匹配成员函数指针:
template<typename>
struct member_test;
template<typename Res, typename Class>
struct member_test<Res Class::*>
{
using result_type = Res;
using class_type = Class;
};
struct Test
{
int object;
void function(int) { }
};
using ObjectType = decltype(&Test::object);
using FunctionType = decltype(&Test::function);
static_assert(std::is_same<
typename member_test<ObjectType>::result_type,
int>::value, "");
static_assert(std::is_same<
typename member_test<ObjectType>::class_type,
Test>::value, "");
static_assert(std::is_same<
typename member_test<FunctionType>::result_type,
void(int)>::value, "");
static_assert(std::is_same<
typename member_test<FunctionType>::class_type,
Test>::value, "");
ObjectType
可以匹配Res Class::*
,其中Res
为int
,Class
为Test
,这完全符合预期。令人震惊的是,FunctionType
也可以匹配Res Class::*
!其中Class
依然为Test
,而Res
为函数类型void(int)
。
那么是否可以写一个类模板,只能匹配成员函数指针而无法匹配对象成员指针呢?在此之前,为了能够更有说服力地用static_assert
表示一个类没有result_type
成员类型(而不是在编译错误后把代码注释掉),我写了个has_result_type
类型,用的是昨天刚写过的void_t技巧:
template<typename T, typename = void>
struct has_result_type
: std::false_type { };
template<typename T>
struct has_result_type<T, std::void_t<typename T::result_type>>
: std::true_type { };
只匹配成员函数指针,需要加上一个可变参数:
template<typename>
struct member_function_test;
template<typename Res, typename Class, typename... Args>
struct member_function_test<Res (Class::*)(Args...)>
{
using result_type = Res;
using class_type = Class;
};
static_assert(!has_result_type<
member_function_test<ObjectType>>::value, "");
static_assert(has_result_type<
member_function_test<FunctionType>>::value, "");
static_assert(std::is_same<
typename member_function_test<FunctionType>::result_type,
void>::value, "");
那么只匹配对象成员指针呢?很简单,只需写一个全部匹配的,再去掉成员函数指针即可:
template<typename>
struct member_object_test;
template<typename Res, typename Class>
struct member_object_test<Res Class::*>
{
using result_type = Res;
using class_type = Class;
};
template<typename Res, typename Class, typename... Args>
struct member_object_test<Res (Class::*)(Args...)> { };
static_assert(has_result_type<
member_object_test<ObjectType>>::value, "");
static_assert(!has_result_type<
member_object_test<FunctionType>>::value, "");
static_assert(std::is_same<
typename member_object_test<ObjectType>::result_type,
int>::value, "");
如果成员函数有const
或&
会怎样?
struct Test
{
int object;
void function(int) { }
void function_const(int) const { }
void function_ref(int) & { }
};
static_assert(std::is_same<
typename member_test<decltype(&Test::function_const)>::result_type,
void(int) const>::value, "");
static_assert(std::is_same<
typename member_test<decltype(&Test::function_const)>::class_type,
Test>::value, "");
static_assert(std::is_same<
typename member_test<decltype(&Test::function_ref)>::result_type,
void(int) &>::value, "");
static_assert(std::is_same<
typename member_test<decltype(&Test::function_ref)>::class_type,
Test>::value, "");
Res Class::*
中的Class
还是不变,但是Res
变成了后加const
和&
的函数类型。关于这两个类型我没有查到相关资料,只知道它们的std::is_function_v
为true
。不过这就够了。
mem_fn
懒得写了,照搬cppreference上的代码:
#include <functional>
#include <iostream>
struct Foo {
void display_greeting() {
std::cout << "Hello, world.\n";
}
void display_number(int i) {
std::cout << "number: " << i << '\n';
}
int data = 7;
};
int main() {
Foo f;
auto greet = std::mem_fn(&Foo::display_greeting);
greet(f);
auto print_num = std::mem_fn(&Foo::display_number);
print_num(f, 42);
auto access_data = std::mem_fn(&Foo::data);
std::cout << "data: " << access_data(f) << '\n';
}
输出:
Hello, world.
number: 42
data: 7
我寻思着你能读到这儿也不用我介绍std::mem_fn
了吧,我的心思在它的实现上。
顺便提醒,不要跟std::mem_fun
搞混,那玩意儿是C++98的化石。
实现
std::mem_fn
基于std::invoke
,std::invoke
又基于std::result_of
,所以从std::result_of
讲起。
SFINAE
在C++中,检查一句语句是否合法有三种方式:目测、看编译器给不给error、SFINAE。对于模板代码,Visual Studio都智能不起来,更别说目测了;我们又不想看到编译器的error,所以得学习SFINAE,Substitution Failure Is Not An Error,替换失败不是错误。
struct __result_of_other_impl
{
template<typename _Fn, typename... _Args>
static __result_of_success<decltype(
std::declval<_Fn>()(std::declval<_Args>()...)
), __invoke_other> _S_test(int);
template<typename...>
static __failure_type _S_test(...);
};
template<typename _Functor, typename... _ArgTypes>
struct __result_of_impl<false, false, _Functor, _ArgTypes...>
: private __result_of_other_impl
{
typedef decltype(_S_test<_Functor, _ArgTypes...>(0)) type;
};
__result_of_other_impl
里有两个重载函数_S_test
,__result_of_impl通过
decltype获得它的返回类型。当
_Functor(_ArgTypes...)语句合法时,第一个
_S_test安好,
int优于
...,重载决议为第一个,
type定义为
_S_test前面一长串;不合法时,第一个
_S_test实例化失败,但是模板替换失败不是错误,编译器继续寻找正确的重载,找到第二个
_S_test,它的变参模板和可变参数像黑洞一样吞噬一切调用,一定能匹配上,
type定义为
__failure_type`。
后文中凡是出现_S_test
的地方都使用了SFINAE的技巧。
result_of
// For several sfinae-friendly trait implementations we transport both the
// result information (as the member type) and the failure information (no
// member type). This is very similar to std::enable_if, but we cannot use
// them, because we need to derive from them as an implementation detail.
template<typename _Tp>
struct __success_type
{ typedef _Tp type; };
struct __failure_type
{ };
/// result_of
template<typename _Signature>
class result_of;
// Sfinae-friendly result_of implementation:
#define __cpp_lib_result_of_sfinae 201210
struct __invoke_memfun_ref { };
struct __invoke_memfun_deref { };
struct __invoke_memobj_ref { };
struct __invoke_memobj_deref { };
struct __invoke_other { };
// Associate a tag type with a specialization of __success_type.
template<typename _Tp, typename _Tag>
struct __result_of_success : __success_type<_Tp>
{ using __invoke_type = _Tag; };
// [func.require] paragraph 1 bullet 1:
struct __result_of_memfun_ref_impl
{
template<typename _Fp, typename _Tp1, typename... _Args>
static __result_of_success<decltype(
(std::declval<_Tp1>().*std::declval<_Fp>())(std::declval<_Args>()...)
), __invoke_memfun_ref> _S_test(int);
template<typename...>
static __failure_type _S_test(...);
};
template<typename _MemPtr, typename _Arg, typename... _Args>
struct __result_of_memfun_ref
: private __result_of_memfun_ref_impl
{
typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type;
};
// [func.require] paragraph 1 bullet 2:
struct __result_of_memfun_deref_impl
{
template<typename _Fp, typename _Tp1, typename... _Args>
static __result_of_success<decltype(
((*std::declval<_Tp1>()).*std::declval<_Fp>())(std::declval<_Args>()...)
), __invoke_memfun_deref> _S_test(int);
template<typename...>
static __failure_type _S_test(...);
};
template<typename _MemPtr, typename _Arg, typename... _Args>
struct __result_of_memfun_deref
: private __result_of_memfun_deref_impl
{
typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type;
};
// [func.require] paragraph 1 bullet 3:
struct __result_of_memobj_ref_impl
{
template<typename _Fp, typename _Tp1>
static __result_of_success<decltype(
std::declval<_Tp1>().*std::declval<_Fp>()
), __invoke_memobj_ref> _S_test(int);
template<typename, typename>
static __failure_type _S_test(...);
};
template<typename _MemPtr, typename _Arg>
struct __result_of_memobj_ref
: private __result_of_memobj_ref_impl
{
typedef decltype(_S_test<_MemPtr, _Arg>(0)) type;
};
// [func.require] paragraph 1 bullet 4:
struct __result_of_memobj_deref_impl
{
template<typename _Fp, typename _Tp1>
static __result_of_success<decltype(
(*std::declval<_Tp1>()).*std::declval<_Fp>()
), __invoke_memobj_deref> _S_test(int);
template<typename, typename>
static __failure_type _S_test(...);
};
template<typename _MemPtr, typename _Arg>
struct __result_of_memobj_deref
: private __result_of_memobj_deref_impl
{
typedef decltype(_S_test<_MemPtr, _Arg>(0)) type;
};
template<typename _MemPtr, typename _Arg>
struct __result_of_memobj;
template<typename _Res, typename _Class, typename _Arg>
struct __result_of_memobj<_Res _Class::*, _Arg>
{
typedef typename remove_cv<typename remove_reference<
_Arg>::type>::type _Argval;
typedef _Res _Class::* _MemPtr;
typedef typename conditional<__or_<is_same<_Argval, _Class>,
is_base_of<_Class, _Argval>>::value,
__result_of_memobj_ref<_MemPtr, _Arg>,
__result_of_memobj_deref<_MemPtr, _Arg>
>::type::type type;
};
template<typename _MemPtr, typename _Arg, typename... _Args>
struct __result_of_memfun;
template<typename _Res, typename _Class, typename _Arg, typename... _Args>
struct __result_of_memfun<_Res _Class::*, _Arg, _Args...>
{
typedef typename remove_cv<typename remove_reference<
_Arg>::type>::type _Argval;
typedef _Res _Class::* _MemPtr;
typedef typename conditional<__or_<is_same<_Argval, _Class>,
is_base_of<_Class, _Argval>>::value,
__result_of_memfun_ref<_MemPtr, _Arg, _Args...>,
__result_of_memfun_deref<_MemPtr, _Arg, _Args...>
>::type::type type;
};
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 2219. INVOKE-ing a pointer to member with a reference_wrapper
// as the object expression
// Used by result_of, invoke etc. to unwrap a reference_wrapper.
template<typename _Tp, typename _Up = typename decay<_Tp>::type>
struct __inv_unwrap
{
using type = _Tp;
};
template<typename _Tp, typename _Up>
struct __inv_unwrap<_Tp, reference_wrapper<_Up>>
{
using type = _Up&;
};
template<bool, bool, typename _Functor, typename... _ArgTypes>
struct __result_of_impl
{
typedef __failure_type type;
};
template<typename _MemPtr, typename _Arg>
struct __result_of_impl<true, false, _MemPtr, _Arg>
: public __result_of_memobj<typename decay<_MemPtr>::type,
typename __inv_unwrap<_Arg>::type>
{ };
template<typename _MemPtr, typename _Arg, typename... _Args>
struct __result_of_impl<false, true, _MemPtr, _Arg, _Args...>
: public __result_of_memfun<typename decay<_MemPtr>::type,
typename __inv_unwrap<_Arg>::type, _Args...>
{ };
// [func.require] paragraph 1 bullet 5:
struct __result_of_other_impl
{
template<typename _Fn, typename... _Args>
static __result_of_success<decltype(
std::declval<_Fn>()(std::declval<_Args>()...)
), __invoke_other> _S_test(int);
template<typename...>
static __failure_type _S_test(...);
};
template<typename _Functor, typename... _ArgTypes>
struct __result_of_impl<false, false, _Functor, _ArgTypes...>
: private __result_of_other_impl
{
typedef decltype(_S_test<_Functor, _ArgTypes...>(0)) type;
};
// __invoke_result (std::invoke_result for C++11)
template<typename _Functor, typename... _ArgTypes>
struct __invoke_result
: public __result_of_impl<
is_member_object_pointer<
typename remove_reference<_Functor>::type
>::value,
is_member_function_pointer<
typename remove_reference<_Functor>::type
>::value,
_Functor, _ArgTypes...
>::type
{ };
template<typename _Functor, typename... _ArgTypes>
struct result_of<_Functor(_ArgTypes...)>
: public __invoke_result<_Functor, _ArgTypes...>
{ };
/// std::invoke_result
template<typename _Functor, typename... _ArgTypes>
struct invoke_result
: public __invoke_result<_Functor, _ArgTypes...>
{ };
std::result_of
和std::invoke_result
本质上是相同的,无非是模板参数_Functor(_ArgTypes...)
和_Functor, _ArgTypes...
的区别,前者在C++17中废弃,后者在C++17中加入。
__invoke_result
借助_Functor
的类型分为三种情况:
-
__result_of_impl<false, false, _Functor, _ArgTypes...>
,可调用对象类型不是成员指针,继承__result_of_other_impl
,后者在上一节介绍过了; -
__result_of_impl<true, false, _MemPtr, _Arg>
,可调用对象是对象成员指针,继承__result_of_memobj
:-
当
_Argval
与_Class
相同或_Class
是_Argval
的基类时(其实is_base_of
就可以概括这种关系;子类成员可以调用基类成员指针),使用__result_of_memobj_ref
,调用方式为.*
; -
否则,调用参数是个指针,使用
__result_of_memobj_deref
,调用方式为->*
;
-
-
__result_of_impl<false, true, _MemPtr, _Arg, _Args...>
,可调用对象是成员函数指针,详细讨论与上一种情况类似,不再赘述。
总之,对于合法的调用类型,__invoke_result
最后继承到__success_type
,定义type
为返回类型;否则继承__failure_type
,没有type
成员。
Tag Dispatching
你注意到了吗?__result_of_success
把__success_type
包装了一下,加入了_Tag
模板参数并定义为__invoke_type
。在随后的实例化中,__invoke_type
都是以下5个类型之一:
struct __invoke_memfun_ref { };
struct __invoke_memfun_deref { };
struct __invoke_memobj_ref { };
struct __invoke_memobj_deref { };
struct __invoke_other { };
这些类型极大地简化了__invoke
的实现:
// Used by __invoke_impl instead of std::forward<_Tp> so that a
// reference_wrapper is converted to an lvalue-reference.
template<typename _Tp, typename _Up = typename __inv_unwrap<_Tp>::type>
constexpr _Up&&
__invfwd(typename remove_reference<_Tp>::type& __t) noexcept
{ return static_cast<_Up&&>(__t); }
template<typename _Res, typename _Fn, typename... _Args>
constexpr _Res
__invoke_impl(__invoke_other, _Fn&& __f, _Args&&... __args)
{ return std::forward<_Fn>(__f)(std::forward<_Args>(__args)...); }
template<typename _Res, typename _MemFun, typename _Tp, typename... _Args>
constexpr _Res
__invoke_impl(__invoke_memfun_ref, _MemFun&& __f, _Tp&& __t,
_Args&&... __args)
{ return (__invfwd<_Tp>(__t).*__f)(std::forward<_Args>(__args)...); }
template<typename _Res, typename _MemFun, typename _Tp, typename... _Args>
constexpr _Res
__invoke_impl(__invoke_memfun_deref, _MemFun&& __f, _Tp&& __t,
_Args&&... __args)
{
return ((*std::forward<_Tp>(__t)).*__f)(std::forward<_Args>(__args)...);
}
template<typename _Res, typename _MemPtr, typename _Tp>
constexpr _Res
__invoke_impl(__invoke_memobj_ref, _MemPtr&& __f, _Tp&& __t)
{ return __invfwd<_Tp>(__t).*__f; }
template<typename _Res, typename _MemPtr, typename _Tp>
constexpr _Res
__invoke_impl(__invoke_memobj_deref, _MemPtr&& __f, _Tp&& __t)
{ return (*std::forward<_Tp>(__t)).*__f; }
/// Invoke a callable object.
template<typename _Callable, typename... _Args>
constexpr typename __invoke_result<_Callable, _Args...>::type
__invoke(_Callable&& __fn, _Args&&... __args)
noexcept(__is_nothrow_invocable<_Callable, _Args...>::value)
{
using __result = __invoke_result<_Callable, _Args...>;
using __type = typename __result::type;
using __tag = typename __result::__invoke_type;
return std::__invoke_impl<__type>(__tag{}, std::forward<_Callable>(__fn),
std::forward<_Args>(__args)...);
}
/// Invoke a callable object.
template<typename _Callable, typename... _Args>
inline invoke_result_t<_Callable, _Args...>
invoke(_Callable&& __fn, _Args&&... __args)
noexcept(is_nothrow_invocable_v<_Callable, _Args...>)
{
return std::__invoke(std::forward<_Callable>(__fn),
std::forward<_Args>(__args)...);
}
__invoke
中定义这个__invoke_type
为__tag
,然后调用__invoke_impl
时把__tag
的实例传入,根据__tag
的类型,编译器将重载函数决议为5个__invoke_impl
中对应的那个。
这种技巧称为tag dispatching,我在std::function
中也介绍过。
mem_fn
template<typename _MemFunPtr,
bool __is_mem_fn = is_member_function_pointer<_MemFunPtr>::value>
class _Mem_fn_base
: public _Mem_fn_traits<_MemFunPtr>::__maybe_type
{
using _Traits = _Mem_fn_traits<_MemFunPtr>;
using _Arity = typename _Traits::__arity;
using _Varargs = typename _Traits::__vararg;
template<typename _Func, typename... _BoundArgs>
friend struct _Bind_check_arity;
_MemFunPtr _M_pmf;
public:
using result_type = typename _Traits::__result_type;
explicit constexpr
_Mem_fn_base(_MemFunPtr __pmf) noexcept : _M_pmf(__pmf) { }
template<typename... _Args>
auto
operator()(_Args&&... __args) const
noexcept(noexcept(
std::__invoke(_M_pmf, std::forward<_Args>(__args)...)))
-> decltype(std::__invoke(_M_pmf, std::forward<_Args>(__args)...))
{ return std::__invoke(_M_pmf, std::forward<_Args>(__args)...); }
};
template<typename _MemObjPtr>
class _Mem_fn_base<_MemObjPtr, false>
{
using _Arity = integral_constant<size_t, 0>;
using _Varargs = false_type;
template<typename _Func, typename... _BoundArgs>
friend struct _Bind_check_arity;
_MemObjPtr _M_pm;
public:
explicit constexpr
_Mem_fn_base(_MemObjPtr __pm) noexcept : _M_pm(__pm) { }
template<typename _Tp>
auto
operator()(_Tp&& __obj) const
noexcept(noexcept(std::__invoke(_M_pm, std::forward<_Tp>(__obj))))
-> decltype(std::__invoke(_M_pm, std::forward<_Tp>(__obj)))
{ return std::__invoke(_M_pm, std::forward<_Tp>(__obj)); }
};
template<typename _MemberPointer>
struct _Mem_fn; // undefined
template<typename _Res, typename _Class>
struct _Mem_fn<_Res _Class::*>
: _Mem_fn_base<_Res _Class::*>
{
using _Mem_fn_base<_Res _Class::*>::_Mem_fn_base;
};
template<typename _Tp, typename _Class>
inline _Mem_fn<_Tp _Class::*>
mem_fn(_Tp _Class::* __pm) noexcept
{
return _Mem_fn<_Tp _Class::*>(__pm);
}
std::mem_fn
返回类型为_Mem_fn
,_Mem_fn
继承_Mem_fn_base
,后者分对象成员指针与成员函数指针两种情况,operator()
都转发参数调用__invoke
。
原文链接:https://www.cnblogs.com/jerry-fuyi/p/12756969.html
如有疑问请与原作者联系
标签:
版权申明:本站文章部分自网络,如有侵权,请联系:west999com@outlook.com
特别注意:本站所有转载文章言论不代表本站观点,本站所提供的摄影照片,插画,设计作品,如需使用,请与原作者联系,版权归原作者所有
- C++ this指针 2020-06-03
- C++ const成员函数 2020-06-03
- 纯虚函数与基类指针数组的运用 代码参考 2020-04-30
- 公有继承中派生类Student对基类Person成员的访问 代码参考 2020-04-20
- 第三章 类与对象进阶 2020-04-04
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