VC的function类说明 -- 继续
我在之前的随笔中介绍了function如何保存参数,如何实现调用相关知识。对于一个函数对象或者函数指针来说,应该很容易理解。不过对于如何在function中保存类的成员函数,这个还是值得一说的。
还是按照之前的方式,通过boost的type_index,我们可以比较容易的知道function的父类是_Func_class。
这里先看一段代码:
template<class _Fx, class _Inv_res = typename _Mybase::template _Result_of_invoking_t<_Fx&>, class = typename _Mybase::template _Enable_if_returnable_t<_Inv_res> > function(_Fx _Func) { // construct wrapper holding copy of _Func this->_Reset(_STD move(_Func)); }
这个是function的一个构造函数,其中的_Inv_res是这个构造函数能够使用的条件,条件的内容是_Mybase::_Result_of_invoking_t<_Fx&>可以获得一个类型。
现在我们查看_Result_of_invoking_t定义的位置:
protected: template<class _Fx> using _Result_of_invoking_t = result_of_t<_Fx(_Types...)>;
上面是在_Func_class中的定义。下面给出类result_of_t的定义。
template<class _Ty> using result_of_t = typename result_of<_Ty>::type; template<class _Void, class... _Types> struct _Result_of { // selected when _Fty isn't callable with _Args }; template<class... _Types> struct _Result_of< void_t< _Unique_tag_result_of, // TRANSITION, C1XX decltype(_STD invoke(_STD declval<_Types>()...))>, _Types...> { // selected when _Fty is callable with _Args typedef decltype(_STD invoke(_STD declval<_Types>()...)) type; }; template<class _Fty> struct result_of { // explain usage static_assert(_Always_false<_Fty>::value, "result_of<CallableType> is invalid; use " "result_of<CallableType(zero or more argument types)> instead."); }; #define _RESULT_OF(CALL_OPT, X1, X2) \ template<class _Fty, \ class... _Args> \ struct result_of<_Fty CALL_OPT (_Args...)> \ : _Result_of<void, _Fty, _Args...> \ { /* template to determine result of call operation */ \ };
由上述代码可知,result_of的实现依赖于std::invoke函数的实现。
我们再查看一下function函数的调用路径:
_Ret operator()(_Types... _Args) const { // call through stored object if (_Empty()) _Xbad_function_call(); return (_Getimpl()->_Do_call(_STD forward<_Types>(_Args)...)); }
上述是_Func_class的调用函数。
virtual _Rx _Do_call(_Types&&... _Args) { // call wrapped function return (_Invoke_ret(_Forced<_Rx>(), _Callee(), _STD forward<_Types>(_Args)...)); }
这个是_Func_impl的调用,也就是上面_Getimpl()->_Do_call的实现函数。下面,我们再查看一下_Invoke_ret的实现:
template<class _Cv_void, class... _Valtys> inline void _Invoke_ret(_Forced<_Cv_void, true>, _Valtys&&... _Vals) { // INVOKE, "implicitly" converted to void _STD invoke(_STD forward<_Valtys>(_Vals)...); } template<class _Rx, class... _Valtys> inline _Rx _Invoke_ret(_Forced<_Rx, false>, _Valtys&&... _Vals) { // INVOKE, implicitly converted to _Rx return (_STD invoke(_STD forward<_Valtys>(_Vals)...)); } template<class... _Valtys> inline auto _Invoke_ret(_Forced<_Unforced, false>, _Valtys&&... _Vals) -> decltype(_STD invoke(_STD forward<_Valtys>(_Vals)...)) { // INVOKE, unchanged return (_STD invoke(_STD forward<_Valtys>(_Vals)...)); }
由上面代码可见,无一例外,function的判断和实现都依赖于std::invoke的实现。那么std::invoke是如何实现的呢?
template<class _Callable, class... _Types> inline auto invoke(_Callable&& _Obj, _Types&&... _Args) -> decltype(_Invoker<_Callable, _Types...>::_Call( _STD forward<_Callable>(_Obj), _STD forward<_Types>(_Args)...)) { // INVOKE a callable object return (_Invoker<_Callable, _Types...>::_Call( _STD forward<_Callable>(_Obj), _STD forward<_Types>(_Args)...)); }
在VS2015中,invoke的实现代码如上,可见invoke的实现依赖于_Invoker类。下面,我们查看一下_Invoker的实现:
template<class _Callable, class... _Types> struct _Invoker; template<class _Callable> struct _Invoker<_Callable> : _Invoker_functor { // zero arguments }; template<class _Callable, class _Ty1, class... _Types2> struct _Invoker<_Callable, _Ty1, _Types2...> : _Invoker1<_Callable, _Ty1> { // one or more arguments };
可见,我们需要继续查看_Invoker1的实现:
template<class _Callable, class _Ty1, class _Decayed = typename decay<_Callable>::type, bool _Is_pmf = is_member_function_pointer<_Decayed>::value, bool _Is_pmd = is_member_object_pointer<_Decayed>::value> struct _Invoker1; template<class _Callable, class _Ty1, class _Decayed> struct _Invoker1<_Callable, _Ty1, _Decayed, true, false> : _If<is_base_of< typename _Is_memfunptr<_Decayed>::_Class_type, typename decay<_Ty1>::type>::value, _Invoker_pmf_object, _Invoker_pmf_pointer>::type { // pointer to member function }; template<class _Callable, class _Ty1, class _Decayed> struct _Invoker1<_Callable, _Ty1, _Decayed, false, true> : _If<is_base_of< typename _Is_member_object_pointer<_Decayed>::_Class_type, typename decay<_Ty1>::type>::value, _Invoker_pmd_object, _Invoker_pmd_pointer>::type { // pointer to member data }; template<class _Callable, class _Ty1, class _Decayed> struct _Invoker1<_Callable, _Ty1, _Decayed, false, false> : _Invoker_functor { // function object };
以及实现_Invoker1的底层类:
struct _Invoker_pmf_object { // INVOKE a pointer to member function on an object template <class _Decayed, class _Ty1, class... _Types2> static auto _Call(_Decayed _Pmf, _Ty1&& _Arg1, _Types2&&... _Args) ->decltype((std::forward<_Ty1>(_Arg1).*_Pmf)( std::forward<_Types2>(_Args2)...)) { // INVOKE a pointer to member function on an object return ((_STD forward<_Ty1>(_Arg1).*_Pmf)( std::forward<_Types2>(_Args2)... )); } }; struct _Invoker_pmf_pointer { // INVOKE a pointer to member function on a [smart] pointer template <class _Decayed, class _Ty1, class... _Types2> static auto _Call(_Decayed _Pmf, _Ty1&& _Arg1, _Types2&&... Args2) ->decltype(((*std::forward<_Ty1>(_Arg1)).*_Pmf)( std::forward<_Types2>(_Arg2)...)) { // INVOKE a pointer to member function on a [smart] pointer return (((*std::forward<_Ty1>(_Arg1)).*_Pmf)( std::forward<_Types2>(_Arg2)...)); } }; struct _Invoker_pmd_object { // INVOKE a pointer to member data on an object template<class _Decayed, class _Ty1> static auto _Call(_Decayed _Pmd, _Ty1&& _Arg1) ->decltype(std::forward<_Ty1>(_Arg1).*_Pmd) { // INVOKE a pointer to member data on a [smart] pointer return (std::forward<_Ty1>(_Arg1).*_Pmd); } }; struct _Invoker_pmd_pointer { // INVOKE a pointer to member data on a [smart] pointer template <class _Decayed, class _Ty1> static auto _Call(_Decayed _Pmd, _Ty1&& _Arg1) ->decltype((*std::forward<_Ty1>(_Arg1)).*_Pmd) { // INVOKE a pointer to member data on a [smart] pointer return ((*std::forward<_Ty1>(_Arg1)).*_Pmd); } }; struct _Invoker_functor { // INVOKE a function object template <class _Callable, class... _Types> static auto _Call(_Callable&& _Obj, _Types&&... _Args) ->decltype(std::forward<_Callable>(_Obj)( std::forward<_Types>(_Args)...)) { // INVOKE a function object return (std::forward<_Callable>(_Obj)( std::forward<_Types>(_Args)...)); } };
实现的过程,主要在于:bool _Is_pmf = is_member_function_pointer<_Decayed>::value和bool _Is_pmd = is_member_object_pointer<_Decayed>::value>两个判断语句,通过这个来实现SFINAE的语义,从而实现针对类型的特例化。为了说明上面两个判断才是重点,输入如下代码:
class A { public: A(){} void printA() const { std::cout << "printA" << std::endl; } }; void printB(A a) { std::cout << "printB" << std::endl; } int main() { std::_Invoker_pmf_object::_Call(&A::printA, A()); std::_Invoker_pmf_pointer::_Call(&A::printA, &A()); std::_Invoker_functor::_Call(printB, A()); return 0; }
查看打印结果。由于_Invoker_pmf_object,_Invoker_pmf_pointer和_Invoker_functor的实现本来很简单,所以invoke调用的重点在于上述判断语句。这里就解释到此,时间仓促,希望见谅。
上一篇: 爆笑囧事儿,呼呼哈哈噗...
下一篇: 小白对异步IO的理解