【C++ 泛型编程 进阶篇】C++ 元模板推导函数调用的结果类型 std::result_of/std::invoke_result全面教程

1. 引言

在C++的世界中，std::result_of和std::invoke_result是两个非常重要的工具，它们都是用于推导函数调用的结果类型。在C++17中，std::result_of被std::invoke_result取代，这是因为std::invoke_result提供了更好的类型推导。

1.1 std::result_of和std::invoke_result的简介

std::result_of是一个模板类，它可以用于推导函数调用的结果类型。它的使用方式是std::result_of::type，其中F是函数类型，Args...是参数类型列表。然而，从C++17开始，std::result_of已经被弃用，取而代之的是std::invoke_result。

std::invoke_result也是一个模板类，它的使用方式是std::invoke_result_t，其中F是函数类型，Args...是参数类型列表。与std::result_of不同，std::invoke_result可以处理更多的情况，例如成员函数指针和成员数据指针。

在实际的编程中，我们通常使用这些工具来推导函数调用的结果类型，这样可以使代码更加灵活和可维护。例如，我们可以使用它们来实现泛型编程，这是一种编程范式，它允许程序员编写可以处理任何类型的代码，而不需要在编写代码时知道这些类型的具体信息。

在英语口语交流中，我们通常会说 “I am using std::result_of or std::invoke_result to deduce the result type of a function call.”（我正在使用std::result_of或std::invoke_result来推导函数调用的结果类型）。在这个句子中，“using”（使用）是一个动词，“to deduce”（来推导）是一个不定式，用来表示目的。

// 一个使用std::invoke_result的例子
#include <type_traits>
#include <functional>
template<typename Callable, typename... Args>
using result_of_t = typename std::invoke_result<Callable, Args...>::type;
template<typename Callable, typename... Args>
result_of_t<Callable, Args...> call(Callable&& f, Args&&... args) {
    return f(std::forward<Args>(args)...);
}
int add(int a, int b) {
    return a + b;
}
int main() {
    auto result = call(add, 1, 2);  // result的类型被推导为int
    return 0;
}

在这个例子中，我们定义了一个名为call的函数模板，它接受一个可调用对象和一些参数，然后调用这个可调用对象，并返回结果。

2. 深入std::result_of和std::invoke_result

2.1 深入理解std::result_of

std::result_of是一个模板类，它可以用于推导函数调用的结果类型。它的使用方式是std::result_of::type，其中F是函数类型，Args...是参数类型列表。然而，从C++17开始，std::result_of已经被弃用，取而代之的是std::invoke_result。

在泛型编程中，std::result_of的一个常见用途是在编写模板函数时推导函数调用的返回类型。例如，考虑以下代码：

template<typename Func, typename Arg>
auto call(Func f, Arg a) -> typename std::result_of<Func(Arg)>::type {
    return f(a);
}

在这个例子中，std::result_of::type用于推导call函数的返回类型。这样，无论f函数的实际返回类型是什么，call函数都能正确地推导出它。

然而，std::result_of有一个限制，那就是它不能处理返回类型为void的函数。这是因为std::result_of试图形成一个类型，而void不是一个完整的类型。这就是为什么在C++17中，std::result_of被std::invoke_result取代的原因。

2.2 深入理解std::invoke_result

std::invoke_result也是一个模板类，它的使用方式是std::invoke_result_t，其中F是函数类型，Args...是参数类型列表。与std::result_of不同，std::invoke_result可以处理更多的情况，例如成员函数指针和成员数据指针。

在泛型编程中，std::invoke_result的一个常见用途是在编写模板函数时推导函数调用的返回类型。例如，考虑以下代码：

template<typename Func, typename Arg>
auto call(Func f, Arg a) -> std::invoke_result_t<Func, Arg> {
    return f(a);
}

在这个例子中，std::invoke_result_t用于推导call函数的返回类型。这样，无论f函数的实际返回类型是什么，call函数都能正确地推导出它。

此外，std::invoke_result还可以处理返回类型为void的函数，这是它比std::result_of更强大的地方。

对不起，我犯了一个错误。我应该开始写第2章的第3节。让我们继续。

2.3 std::result_of和std::invoke_result的区别和联系

std::result_of和std::invoke_result都是用于推导函数调用结果类型的工具，但它们在使用和实现上有一些重要的区别。

首先，std::result_of在C++17中被弃用，取而代之的是std::invoke_result。这是因为std::invoke_result提供了更好的类型推导，特别是对于返回类型为void的函数和成员函数指针。

其次，std::result_of和std::invoke_result的使用方式也有所不同。std::result_of的使用方式是std::result_of::type，其中F是函数类型，Args...是参数类型列表。而std::invoke_result的使用方式是std::invoke_result_t，其中F是函数类型，Args...是参数类型列表。

尽管std::result_of在C++17中被弃用，但在旧的代码中仍然可以看到它的身影。因此，理解std::result_of和std::invoke_result的区别和联系对于阅读和理解C++代码是非常重要的。

在英语口语交流中，我们通常会说 “In C++17, std::result_of is deprecated and replaced by std::invoke_result, which provides better type deduction.”（在C++17中，std::result_of已被弃用，被提供了更好的类型推导的std::invoke_result取代。）

接下来，让我们通过一些代码示例来进一步理解std::result_of和std::invoke_result的区别和联系。

#include <type_traits>
#include <functional>
// 使用std::result_of推导函数调用结果类型
template<typename Func, typename Arg>
auto call_with_result_of(Func f, Arg a) -> typename std::result_of<Func(Arg)>::type {
    return f(a);
}
// 使用std::invoke_result推导函数调用结果类型
template<typename Func, typename Arg>
auto call_with_invoke_result(Func f, Arg a) -> std::invoke_result_t<Func, Arg> {
    return f(a);
}
int add(int a, int b) {
    return a + b;
}
int main() {
    auto result1 = call_with_result_of(add, 1, 2);  // 使用std::result_of
    auto result2 = call_with_invoke_result(add, 1, 2);  // 使用std::invoke_result
    return 0;
}

在这个例子中，我们定义了两个函数模板call_with_result_of和call_with_invoke_result，分别使用std::result_of和std::invoke_result来推导函数调用的结果类型。

2.4 根据编译器版本来选择不同的接口示例

你可以使用预处理器指令来检查GCC的版本。GCC定义了几个宏来表示其版本号，其中__GNUC__表示主版本号，__GNUC_MINOR__表示次版本号。

以下是一个示例，如何使用这些宏来决定是否使用std::invoke_result或std::result_of：

#include <type_traits>
#include <iostream>
#if __GNUC__ > 7 || (__GNUC__ == 7 && __GNUC_MINOR__ >= 1)
    #define USE_INVOKE_RESULT
#endif
#ifdef USE_INVOKE_RESULT
template<typename Callable, typename... Args>
auto invoke_and_print_type(Callable&& f, Args&&... args) -> typename std::invoke_result<Callable, Args...>::type {
    using result_type = typename std::invoke_result<Callable, Args...>::type;
#else
template<typename Callable, typename... Args>
auto invoke_and_print_type(Callable&& f, Args&&... args) -> typename std::result_of<Callable(Args...)>::type {
    using result_type = typename std::result_of<Callable(Args...)>::type;
#endif
    std::cout << "Result type: " << typeid(result_type).name() << '\n';
    return f(std::forward<Args>(args)...);
}
int add(int a, int b) {
    return a + b;
}
int main() {
    auto result = invoke_and_print_type(add, 5, 3);
    std::cout << "Result: " << result << '\n';
}

在这段代码中，我们首先检查GCC的版本。如果版本高于或等于7.1（即支持C++17），我们就定义一个宏USE_INVOKE_RESULT。然后根据是否定义了这个宏，选择使用std::invoke_result还是std::result_of。

3. 使用场景

在这一章节中，我们将深入探讨std::result_of和std::invoke_result在C++编程中的主要使用场景。这两个模板类主要用于推导函数调用的结果类型，这在模板元编程和函数返回类型推导中非常有用。

3.1 std::result_of和std::invoke_result在模板元编程中的应用

在模板元编程（Metaprogramming）中，我们经常需要在编译时确定函数的返回类型。std::result_of和std::invoke_result可以帮助我们实现这一目标。

例如，假设我们有一个模板函数foo，它接受一个函数对象f和一个参数x，并返回f(x)的结果。我们可以使用std::result_of或std::invoke_result来推导f(x)的返回类型。

template <typename Func, typename Arg>
auto foo(Func f, Arg x) -> typename std::result_of<Func(Arg)>::type // 或者 std::invoke_result_t<Func, Arg>
{
    return f(x);
}

在这个例子中，std::result_of::type（或std::invoke_result_t）会在编译时推导出f(x)的返回类型。这样，我们就可以在不知道f和x具体类型的情况下，编写出灵活且类型安全的代码。

在口语交流中，我们可以这样描述上述代码：“We have a template function foo that takes a function object f and an argument x, and returns the result of f(x). The return type is deduced at compile time using std::result_of or std::invoke_result."（我们有一个模板函数foo，它接受一个函数对象f和一个参数x，并返回f(x)的结果。返回类型是在编译时使用std::result_of或std::invoke_result推导出来的。）

3.2 std::result_of和std::invoke_result在函数返回类型推导中的应用

在C++11及其后续版本中，函数的返回类型可以通过auto关键字和尾返回类型语法进行推导。std::result_of和std::invoke_result在这方面非常有用。

例如，假设我们有一个函数bar，它接受一个函数对象f和两个参数x和y，并返回f(x, y)的结果。我们可以使用std::result_of或std::invoke_result来推导f(x, y)的返回类型。

template <typename Func, typename Arg1, typename Arg2>
auto bar(Func f, Arg1 x, Arg2 y) -> typename std::result_of
<Func(Arg1, Arg2)>::type // 或者 std::invoke_result_t<Func, Arg1, Arg2>
{
    return f(x, y);
}

在这个例子中，std::result_of::type（或std::invoke_result_t）会在编译时推导出f(x, y)的返回类型。这样，我们就可以在不知道f、x和y具体类型的情况下，编写出灵活且类型安全的代码。

在口语交流中，我们可以这样描述上述代码：“We have a function bar that takes a function object f and two arguments x and y, and returns the result of f(x, y). The return type is deduced at compile time using std::result_of or std::invoke_result."（我们有一个函数bar，它接受一个函数对象f和两个参数x和y，并返回f(x, y)的结果。返回类型是在编译时使用std::result_of或std::invoke_result推导出来的。）

在这两个例子中，我们可以看到std::result_of和std::invoke_result在模板元编程和函数返回类型推导中的强大应用。它们使我们能够在编译时确定函数的返回类型，从而编写出更灵活、更安全的代码。

4. 注意事项

在这一章节中，我们将深入探讨std::result_of和std::invoke_result的使用限制和注意事项，以及为什么std::result_of在C++17中被弃用。

4.1 std::result_of和std::invoke_result的使用限制

std::result_of和std::invoke_result都是用于推导函数调用的结果类型的模板，但是它们并不是万能的。在使用它们时，我们需要注意以下几点：

• 函数类型（Function Types）：std::result_of和std::invoke_result只能用于函数类型，不能用于非函数类型。例如，如果我们尝试对一个整数类型使用std::result_of或std::invoke_result，编译器会报错。
  
• 函数参数（Function Arguments）：在使用std::result_of和std::invoke_result时，我们需要提供函数的参数类型。如果函数参数类型不正确，或者参数数量不匹配，编译器也会报错。
  
• 函数可调用性（Function Callable）：std::result_of和std::invoke_result只能用于可调用的函数。如果函数不可调用（例如，函数是私有的），编译器会报错。
  

以下是一个使用std::result_of和std::invoke_result的代码示例，以及相应的注释：

#include <type_traits>
#include <iostream>
// 定义一个函数
int add(int a, int b) {
    return a + b;
}
int main() {
    // 使用std::result_of推导函数返回类型
    std::result_of<decltype(&add)(int, int)>::type result = add(1, 2);
    std::cout << "Result: " << result << std::endl;
    // 使用std::invoke_result推导函数返回类型
    std::invoke_result<decltype(&add), int, int>::type result2 = add(3, 4);
    std::cout << "Result: " << result2 << std::endl;
    return 0;
}

在这个代码示例中，我们首先定义了一个函数add，然后使用std::result_of和std::invoke_result来推导这个函数的返回类型。注意，我们需要提供函数的参数类型（在这个例子中，参数类型是int）。

4.2 std::result_of在C++17中被弃用的原因

在C++17中，std::result_of被弃用，主要原因是其设计存在一些问题。具体来说，std::result_of在处理某些类型的函数时可能会产生错误的结果。例如，如果函数的参数类型是右值引用，std::result_of可能无法正确推导出函数的返回类型。

相比之下，

std::invoke_result的设计更加健壮，能够正确处理各种类型的函数，包括参数类型是右值引用的函数。因此，从C++17开始，推荐使用std::invoke_result来推导函数的返回类型，而不是std::result_of。

以下是一个展示std::result_of和std::invoke_result在处理右值引用函数时行为差异的代码示例：

#include <type_traits>
// 定义一个接受右值引用的函数
void foo(int&&) {}
int main() {
    // 使用std::result_of推导函数返回类型
    // 注意：这将在C++17中产生编译错误
    // std::result_of<decltype(&foo)(int)>::type result;
    // 使用std::invoke_result推导函数返回类型
    // 注意：这将在C++17中正确工作
    std::invoke_result<decltype(&foo), int>::type result2;
    return 0;
}

在这个代码示例中，我们定义了一个接受右值引用的函数foo。然后，我们尝试使用std::result_of和std::invoke_result来推导这个函数的返回类型。可以看到，std::result_of在这种情况下会产生编译错误，而std::invoke_result则能够正确工作。

总的来说，虽然std::result_of和std::invoke_result都是用于推导函数返回类型的工具，但是由于std::result_of的设计问题，从C++17开始，推荐使用std::invoke_result。

5. 为什么使用std::result_of和std::invoke_result

在C++编程中，std::result_of和std::invoke_result是两个非常重要的工具，它们在提高代码的可读性、可维护性以及灵活性和可复用性方面起着关键的作用。

5.1 提高代码的可读性和可维护性

在C++中，我们经常需要处理函数或者函数对象，而这些函数或者函数对象的返回类型可能是复杂的，甚至是依赖于模板参数的。在这种情况下，如果我们直接写出这些复杂的类型，那么代码的可读性和可维护性就会大大降低。这时，std::result_of和std::invoke_result就能派上用场。

例如，我们有一个模板函数foo，它接受一个函数对象f和一个参数x，然后返回f(x)的结果。如果我们不使用std::result_of或者std::invoke_result，那么我们可能需要这样写：

template <typename Func, typename Arg>
auto foo(Func f, Arg x) -> decltype(f(x)) {
    return f(x);
}

在这里，我们使用了decltype来推导f(x)的类型，但是这样的代码并不容易阅读和维护。如果我们使用std::result_of或者std::invoke_result，那么代码就会变得更加清晰：

template <typename Func, typename Arg>
auto foo(Func f, Arg x) -> std::invoke_result_t<Func, Arg> {
    return f(x);
}

在这里，std::invoke_result_t就是f(x)的类型。这样的代码不仅更加清晰，而且更容易维护。

5.2 提高代码的灵活性和可复用性

std::result_of和std::invoke_result不仅可以提高代码的可读性和可维护性，还可以提高代码的灵活性和可复用性。

在C++中，我们经常需要编写一些通用的代码，这些代码需要能够处理各种不同的函数或者函数对象。在这种情况下，std::result_of和std::invoke_result就能派上用场。

例如，我们有一个模板函数bar，它接受一个函数对象f和一个参数x，然后返回f(x)的结果。如果我们不使用std::result_of或者std::invoke_result，那么我们可能需要为每一种可能的f(x)的类型都写一个特化版本的bar。这样的

代码会变得非常复杂和难以维护。但是，如果我们使用std::result_of或者std::invoke_result，那么我们就可以写出一段通用的代码，这段代码可以处理任何类型的f和x。

template <typename Func, typename Arg>
auto bar(Func f, Arg x) -> std::invoke_result_t<Func, Arg> {
    return f(x);
}

在这里，std::invoke_result_t就是f(x)的类型。这样的代码不仅更加清晰和易于维护，而且更加灵活和可复用。

在实际的编程中，我们经常需要编写这种通用的代码，因此std::result_of和std::invoke_result是非常有用的工具。

在口语交流中，我们可以这样描述这个概念：“In C++ programming, std::result_of and std::invoke_result are very useful tools for improving the readability, maintainability, flexibility, and reusability of the code. They allow us to write generic code that can handle any type of function or function object, which is very important in practical programming.”（在C++编程中，std::result_of和std::invoke_result是非常有用的工具，它们可以提高代码的可读性、可维护性、灵活性和可复用性。它们让我们能够编写通用的代码，这些代码可以处理任何类型的函数或函数对象，这在实际编程中非常重要。）

在这个句子中，“In C++ programming”（在C++编程中）是一个介词短语，用来介绍我们正在讨论的主题；“std::result_of and std::invoke_result are very useful tools for improving the readability, maintainability, flexibility, and reusability of the code”（std::result_of和std::invoke_result是非常有用的工具，它们可以提高代码的可读性、可维护性、灵活性和可复用性）是主句，描述了std::result_of和std::invoke_result的作用；“They allow us to write generic code that can handle any type of function or function object”（它们让我们能够编写通用的代码，这些代码可以处理任何类型的函数或函数对象）是一个宾语从句，解释了为什么std::result_of和std::invoke_result是有用的工具；“which is very important in practical programming”（这在实际编程中非常重要）是一个定语从句，进一步强调了这个概念的重要性。

6. 结语

在我们的编程学习之旅中，理解是我们迈向更高层次的重要一步。然而，掌握新技能、新理念，始终需要时间和坚持。从心理学的角度看，学习往往伴随着不断的试错和调整，这就像是我们的大脑在逐渐优化其解决问题的“算法”。

这就是为什么当我们遇到错误，我们应该将其视为学习和进步的机会，而不仅仅是困扰。通过理解和解决这些问题，我们不仅可以修复当前的代码，更可以提升我们的编程能力，防止在未来的项目中犯相同的错误。

我鼓励大家积极参与进来，不断提升自己的编程技术。无论你是初学者还是有经验的开发者，我希望我的博客能对你的学习之路有所帮助。如果你觉得这篇文章有用，不妨点击收藏，或者留下你的评论分享你的见解和经验，也欢迎你对我博客的内容提出建议和问题。每一次的点赞、评论、分享和关注都是对我的最大支持，也是对我持续分享和创作的动力。