std::invoke_result的实现详解

目录

• 目录
• 前言
• invoke_result
• 标准库中的invoke_result
• 我的实现
• 后记

前言

本篇博文将详细介绍一下libstdc++中std::invoke_result的实现过程，由于个人水平不足，可能最终的实现过程略有误差，还请各位指正。

invoke_result

std::invoke_result是C++17标准库里面的一个接口，它可以返回任何可调用的返回值，比如函数，函数对象，对象方法等。它的接口为^[1]

template< class F, class... ArgTypes>
class invoke_result;

在C++17之前，std::invoke_result有一个类似功能的模板，名字为std::result_of，他们之间的差别只有在接口上有略微的差别，

template< class >
class result_of; // not defined

template< class F, class... ArgTypes >
class result_of<F(ArgTypes...)>;

std::result_of于C++17标记为deprecated，并在C++20中被移除。

标准库中的invoke_result

我们首先看看一下标准库中std::invoke_result的实现，了解一下其大致的结构。

graph TD;
invoke_result[std::invoke_result];
result_of[std::result_of];
__invoke_result[std::__invoke_result];
invoke_result --> __invoke_result;
result_of --> __invoke_result;

__result_of_impl[std::__result_of_impl];
__invoke_result --> __result_of_impl;

__result_of_memobj[std::__result_of_memobj];
__result_of_memfun[std::__result_of_memfun];
__result_of_other_impl[std::__result_of_other_impl];

__result_of_impl --> __result_of_memobj;
__result_of_impl --> __result_of_memfun;
__result_of_impl --> __result_of_other_impl;

__S_test["__S_test()"];
__result_of_other_impl --> __S_test;

__result_of_memobj_ref[std::__result_of_memobj_ref];
__result_of_memobj_deref[std::__result_of_memobj_deref];
__result_of_memobj --> __result_of_memobj_ref;
__result_of_memobj --> __result_of_memobj_deref;

__result_of_memfun_ref[std::__result_of_memfun_deref];
__result_of_memfun_deref[std::__result_of_memfun_deref];
__result_of_memfun --> __result_of_memfun_ref;
__result_of_memfun --> __result_of_memfun_deref;

__result_of_memfun_ref_impl[std::__result_of_memfun_ref_impl];
__result_of_memfun_deref_impl[std::__result_of_memfun_deref_impl];
__result_of_memobj_ref_impl[std::__result_of_memobj_ref_impl];
__result_of_memobj_deref_impl[std::__result_of_memobj_deref_impl];

__result_of_memfun_ref --> __result_of_memfun_ref_impl;
__result_of_memfun_deref --> __result_of_memfun_deref_impl;
__result_of_memobj_ref --> __result_of_memobj_ref_impl;
__result_of_memobj_deref --> __result_of_memobj_deref_impl;

__result_of_memfun_ref_impl --> __S_test;
__result_of_memfun_deref_impl --> __S_test;
__result_of_memobj_ref_impl --> __S_test;
__result_of_memobj_deref_impl --> __S_test;

可以看到，整个实现有两层判断（有两个判断是类似的，可以看作是一层），其中第一个层位于std::__result_of_impl，用来判断不同的调用方法，大致分为三种：

1. 对象方法，比如以下代码中的struct A的invoke_mem_fun，调用方法为obj.fun(args...)。

struct A {
  int invoke_mem_fun();
};

1. 对象成员，比如以下代码中的struct B中的invoke_mem_obj，调用方法为obj.fun（其实就是一个简单的引用成员）。

struct B {
  int invoke_mem_obj;
};

1. 其他，比如以下代码中的invoke_other，其调用方法为fun(args...)，这一部分包括了函数对象和普通函数。

int invoke_other();

那么std::__result_of_impl是如何区分出了这三种不同的调用方式呢？

libstdc++中实现了两个类型判断，is_member_object_pointer和is_member_function_pointer。通过这两个判断不同的输出，来区分三种不同的调用方式。

这两个函数的结构差不多，首先会对判断输入的类型是否为对象的成员，判断方法为进行类似下面代码的模式匹配

template<typename>
struct __mem_and_obj_type: public std::__failure_type{};

template<typename _Tp, typename _Cp>
struct __mem_and_obj_type<_Tp _Cp::*> {
 typedef _Tp mem_type;
 typedef _Cp obj_type;
};

这一部分代码是从我实现的部分截取出来的，其中最主要的部分就是_Tp _Cp::*，他分开成员类型和对象类型，如果能分开则为对象的成员。

第二步则是判断上一步分离得到的成员类型是否为函数类型，如果是函数类型，那么其为对象方法，否则为对象成员。

由此，通过那两个类型的判断，可以有三种不同的结果，true,false，false,true，false,false，不同的结果对应着不同的调用方法。看到这里，肯定会有人思考，有没有可能结果都是true呢？

首先从libstdc++实现上这是不可能的，因为在实现第二步的时候，is_member_object_pointer几乎是直接对is_member_function_pointer取反的（实现上取反）。所以，不可能同时出现两个都为true的情况。

而实际中，却的确有可能出现这种情况（我也不知道是不是我那里弄错了，先写下来吧）

struct STest {
  double operator() (int, double) {
    std::cout << "Test" << std::endl;
    return 0;
  }
};

struct CTest {
  struct STest s;
  int s_m(int, double){};
};

这种情况下，如果我们想获得CTest::s的返回值，是有一个很奇怪的情况的，我们是把它当作函数呢，还是一个成员呢？如果从调用的情况来看，CTest::s和CTest::s_m一样，都是obj.fun(args...)，但是实际中，std::invoke_result会将它视为对象成员。所以如果我们使用std::invoke_result<decltype(&CTest::s), CTest, int, double>::type是会报错的，正确的方法是只能使用std::invoke_result<decltype(&CTest::s), CTest>::type。由于没有去查看文献，所以不清楚这一部分是bug还是feature或者是UB，有时间再详细考究一下吧。

好了，目前已经详细说完了std::invoke_result的第一层判断，接下来我们来看看第二层判断。

第二层判断有两个部分，我们只看其中的一个部分，因为实际上这两个部分都是一样的。

这一层的判断位于对象成员和对象方法部分。即区分std::__result_of_memfun_deref和std::__result_of_memfun_ref。这两个的不同之处在于，前者的对象为指针。区分的方法也很简单粗暴，直接判断是否参数里面的对象类型与上文中使用_Tp _Cp::*获得的对象类型_Cp是否一致或者为继承关系，如果为是，则使用std::__result_of_memfun_ref否则为std::__result_of_memfun_deref。

通过上面两层的判断，已经成功的将不同的调用方法进行了分类，接下来就是使用decltype来获取返回值了。这一部分就很简单了，由上面的几次分类，分为了五种不同的调用（加上不同的对象）。

1. __invoke_memfun_ref

(std::declval<_Tp1>().*std::declval<_Fp>())(std::declval<_Args>()...)

1. __invoke_memfun_deref

((*std::declval<_Tp1>()).*std::declval<_Fp>())(std::declval<_Args>()...)

3. `__invoke_memobj_ref`

```C++
std::declval<_Tp1>().*std::declval<_Fp>()

1. __invoke_memobj_deref

(*std::declval<_Tp1>()).*std::declval<_Fp>()

1. __invoke_other

std::declval<_Fn>()(std::declval<_Args>()...)

但是比较好奇的是，程序没有直接通过上面的方法获得，而是构造了一个return_type _S_test(int)，然后获取的。除了返回的类型外，std::invoke_result还保存了调用的类型，即之前提到的那五种，这一部分应该是为了实现std::invoke而保存的。

我的实现

为了学习std::invoke_result，我也实现了一个类似的ink::invoke_result。层次结构类似，不过将_S_test()删去了，改成了直接的实现。

github gist: ink_invoke_result.cpp

后记

阅读标准库里面的实现的确可以学到很多东西，即使以后不会写类似的代码，但是在使用的时候也会对C++有更加清晰的理解。同时也发现了C++目前的一个缺陷，在实现这种接口的时候，免不了要进行多层包装，而每一层的包装，标准库都是直接将其暴露在std命名空间中，这导致了在使用代码提示的时候极大的降低了提示的效率和美观（一大堆的以下划线开头的item真的非常非常非常难看，而且头大）。

博客原文: https://www.cnblogs.com/ink19/p/cpp_invoke_result.html

---

1. std::result_of, std::invoke_result - cppreference.com ︎