成員指針與mem_fn
本文是<functional>系列的第4篇。html
成員指針是一個很是具備C++特點的功能。更低級的語言（如C）沒有類，也就沒有成員的概念；更高級的語言（如Java）沒有指針，即便有也不會有成員指針這麼拗口的東西。ios
上回在Stack Overflow上看到一個問題，C++是否容許delegate = object.method這種寫法。我猜他是從C#過來的。在C++中，這種寫法在語法上是不可能的，語義上能夠用std::bind來實現。而本文的主題std::mem_fn，則是實現了delegate = method的功能，object插到了原來的參數列表的前面，成爲新的函數對象的第一個參數。express
成員指針
先說說成員指針。成員指針，分爲對象成員指針與成員函數指針。下面的程序演示瞭如何定義和使用它們：app
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)。ui
那麼是否能夠寫一個類模板，只能匹配成員函數指針而沒法匹配對象成員指針呢？在此以前，爲了可以更有說服力地用static_assert表示一個類沒有result_type成員類型（而不是在編譯錯誤後把代碼註釋掉），我寫了個has_result_type類型，用的是昨天剛寫過的void_t技巧：spa
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, "");
那麼只匹配對象成員指針呢？很簡單，只需寫一個所有匹配的，再去掉成員函數指針便可：code
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。
相關文章
- 1. C++指針與成員
- 2. C++ 指向成員的指針（數據成員指針，函數成員指針）
- 3. 普通函數指針、成員變量指針與成員函數指針
- 4. C++-成員指針
- 5. C++函數指針相關 & 類成員的指針 & 成員函數的指針
- 6. C++對象指針、對象成員和對象成員指針
- 7. 類成員函數與this指針
- 8. C++ this指針與const成員函數
- 9. 函數指針與類成員函數指針
- 10. c++，new,delete，成員指針
- 更多相關文章...
- • Eclipse 生成jar包 - Eclipse 教程
- • SQL 指南 - 網站建設指南
- • 算法總結-雙指針
- • 互聯網組織的未來：剖析GitHub員工的任性之源
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. 外部其他進程嵌入到qt FindWindow獲得窗口句柄 報錯無法鏈接的外部符號 [email protected] 無法被([email protected]@[email protected]@@引用
- 2. UVa 11524 - InCircle
- 3. The Monocycle（bfs）
- 4. VEC-C滑窗
- 5. 堆排序的應用-TOPK問題
- 6. 實例演示ElasticSearch索引查詢term,match,match_phase,query_string之間的區別
- 7. 數學基礎知識 集合
- 8. amazeUI 復擇框問題解決
- 9. 揹包問題理解
- 10. 算數平均-幾何平均不等式的證明,從麥克勞林到柯西
歡迎關注本站公眾號,獲取更多信息
相關文章