成员指针与mem_fn

本文是的第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类型，用的是昨天刚写过的：

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

懒得写了，照搬上的代码：

#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，我在中也介绍过。

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。