欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

VC的function类说明 -- 继续

程序员文章站 2022-06-22 11:11:53
我在之前的随笔中介绍了function如何保存参数,如何实现调用相关知识。对于一个函数对象或者函数指针来说,应该很容易理解。不过对于如何在function中保存类的成员函数,这个还是值得一说的。 还是按照之前的方式,通过boost的type_index,我们可以比较容易的知道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>::valuebool _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调用的重点在于上述判断语句。这里就解释到此,时间仓促,希望见谅。