C++17之std::invoke: 使用和原理探究(全)

1.概述

2.輔助類

3.原理分析

4.總結

1.概述

????????在之前的 C++ 版本中，要調用不同類型的可調用對象，需要使用不同的語法，例如使用函數調用運算符 () 來調用函數或函數指針，使用成員訪問運算符 -> 或 . 來調用成員函數。這樣的語法差異導致了代碼的冗余和不一致，給編寫和維護代碼帶來了困擾。

????????std::invoke?是 C++17標準庫中引入的一個函數模板，它的引入就是為了解決這個問題，它提供了一種統一的調用語法，無論是調用普通函數、函數指針、類成員函數指針、仿函數、std::function、類成員還是lambda表達式，都可以使用相同的方式進行調用。

????????std::invoke?的語法如下：

template <typename Fn, typename... Args>
decltype(auto) invoke(Fn&& fn, Args&&... args);

它接受一個可調用對象 fn 和相應的參數 args...，并返回調用結果。例如：

#include <functional>
#include <iostream>
#include <type_traits>struct Foo
{Foo(int num) : num_(num) {}void print_add(int i) const { std::cout << num_ + i << '\n'; }int num_;
};void print_num(int i)
{std::cout << i << '\n';
}struct PrintNum
{void operator()(int i) const{std::cout << i << '\n';}
};int main()
{// 調用自由函數std::invoke(print_num, -9);// 調用 lambdastd::invoke([]() { print_num(42); });// 調用成員函數const Foo foo(314159);std::invoke(&Foo::print_add, foo, 1);// 調用（訪問）數據成員std::cout << "num_：" << std::invoke(&Foo::num_, foo) << '\n';// 調用函數對象std::invoke(PrintNum(), 18);#if defined(__cpp_lib_invoke_r)auto add = [](int x, int y) { return x + y; };auto ret = std::invoke_r<float>(add, 11, 22);static_assert(std::is_same<decltype(ret), float>());std::cout << ret << '\n';std::invoke_r<void>(print_num, 44);
#endif
}

可能的輸出：

-9
42
314160
num_：314159
18
33
44

????????通過?std::invoke，我們可以在不關心可調用對象的具體類型的情況下進行調用，提高了代碼的靈活性和可讀性。它尤其適用于泛型編程中需要以統一方式調用各種可調用對象的場景，例如使用函數指針或成員函數指針作為模板參數的算法或容器等。

2.輔助類

? ? ? ? 閱讀后面的內容，你必須事先了解以下內容：

? ? ? ? 1.constexpr

? ? ? ? 2.std::is_base_of_v

? ? ? ? 3.std::remove_cv_t

? ? ? ? 4.std::ref和std::cref

? ? ? ? 5.std::is_member_function_pointer

? ? ? ? 6.std::is_member_object_pointer_v

? ? ? ? 7.左值和右值

3.原理分析

? ? ? ? 從上面的例子我們可以猜想，std::invoke的實現應該是根據傳入的參數Fn來判斷出Fn是否為可調用對象(Callable)，常見的可調用對象有：

function?
member function
function object
lambda expression
bind expression
std::function

如果是可調用對象，那肯定也需要分析出是那種可調用對象，C++涉及到的可調用對象有：

? ? ? ? 1.普通函數，保證了對C的兼容。如：void? func(int x, int y);

? ? ? ? 2.函數指針。和數組名一樣，函數名即為函數指針。如：

	typedef void(*FType)(int); //定義一個函數指針類型Ftypevoid func(FType fn, int x) {fn(x);}

? ? ? ? 3.類成員變量和成員函數

	class CTestabcd{public:inline int func(int a, int b) { return a + b; }public:int  m_i;};using TestFunc = int (CTestabcd::*)(int, int);using TestMember = int(CTestabcd::*);TestFunc gTestFunc = &CTestabcd::func;TestMember gTestMember = &CTestabcd::m_i;

? ? ? ? 4.仿函數(函數對象)，即重載了operator()運算符的類對象，如：

    template <class _Ty = void>struct less {_CXX17_DEPRECATE_ADAPTOR_TYPEDEFS typedef _Ty _FIRST_ARGUMENT_TYPE_NAME;_CXX17_DEPRECATE_ADAPTOR_TYPEDEFS typedef _Ty _SECOND_ARGUMENT_TYPE_NAME;_CXX17_DEPRECATE_ADAPTOR_TYPEDEFS typedef bool _RESULT_TYPE_NAME;_NODISCARD constexpr bool operator()(const _Ty& _Left, const _Ty& _Right) const {return _Left < _Right;}};

? ? ? ? std::bind綁定，它是STL的配接器，用于創建一個可調用的對象，對象里面重載了operator()，也是運用了仿函數的思想，如:?

#include <iostream>  
#include <functional>  
#include <thread>  
#include <chrono>  
#include <vector>  
#include <algorithm>  void print_sum(int x, int y) {  std::cout << x + y << "\n";  
}  int main() {  std::vector<int> nums = {1, 2, 3, 4, 5};  auto bound_sum = std::bind(print_sum, std::placeholders::_1, 5);  // 綁定第二個參數為 5。  std::for_each(nums.begin(), nums.end(), bound_sum);  // 對于每個元素，輸出它與 5 的和。  return 0;  
}

? ? ? ? 5.lambda表達式，如：

auto f = [] { return "hello world"; }; 
cout << f() << endl; // 輸出：hello world

? ? ? ? 6.std::function, 如：

#include <iostream>
#include <functional>// std::function
std::function<int(int, int)> SumFunction;// 普通函數
int func_sum(int a, int b)
{return a + b;
}class Calcu
{
public:int base = 20;// 類的成員方法，參數包含this指針int class_func_sum(const int a, const int b) const { return this->base + a + b; };// 類的靜態成員方法，不包含this指針static int class_static_func_sum(const int a, const int b) { return a + b; };
};// 仿函數
class ImitateAdd
{
public:int operator()(const int a, const int b) const { return a + b; };
};// lambda函數
auto lambda_func_sum = [](int a, int b) -> int { return a + b; };// 函數指針
int (*func_pointer)(int, int);int main(void) 
{int x = 2; int y = 5;// 普通函數SumFunction = func_sum;int sum = SumFunction(x, y);std::cout << "func_sum：" << sum << std::endl;// 類成員函數Calcu obj;SumFunction = std::bind(&Calcu::class_func_sum, obj, std::placeholders::_1, std::placeholders::_2); // 綁定this對象sum = SumFunction(x, y);std::cout << "Calcu::class_func_sum：" << sum << std::endl;// 類靜態函數SumFunction = Calcu::class_static_func_sum;sum = SumFunction(x, y);std::cout << "Calcu::class_static_func_sum：" << sum << std::endl;// lambda函數SumFunction = lambda_func_sum;sum = SumFunction(x, y);std::cout << "lambda_func_sum：" << sum << std::endl;// 帶捕獲的lambda函數int base = 10;auto lambda_func_with_capture_sum = [&base](int x, int y)->int { return x + y + base; };SumFunction = lambda_func_with_capture_sum;sum = SumFunction(x, y);std::cout << "lambda_func_with_capture_sum：" << sum << std::endl;// 仿函數ImitateAdd imitate;SumFunction = imitate;sum = SumFunction(x, y);std::cout << "imitate func：" << sum << std::endl;// 函數指針func_pointer = func_sum;SumFunction = func_pointer;sum = SumFunction(x, y);std::cout << "function pointer：" << sum << std::endl;getchar();return 0;
}

? ? ? ? 通過上面的講解，那我們看看std::invoke是不是這樣去判斷的呢？(以vs2019為藍本)，先看看源碼：

//[1]函數沒有參數的調用方式
template <class _Callable>
_CONSTEXPR17 auto invoke(_Callable&& _Obj) noexcept(noexcept(static_cast<_Callable&&>(_Obj)()))-> decltype(static_cast<_Callable&&>(_Obj)()) {return static_cast<_Callable&&>(_Obj)();
}//[2]除1之外的其他調用方式
template <class _Callable, class _Ty1, class... _Types2>
_CONSTEXPR17 auto invoke(_Callable&& _Obj, _Ty1&& _Arg1, _Types2&&... _Args2) noexcept(noexcept(_Invoker1<_Callable, _Ty1>::_Call(static_cast<_Callable&&>(_Obj), static_cast<_Ty1&&>(_Arg1), static_cast<_Types2&&>(_Args2)...)))-> decltype(_Invoker1<_Callable, _Ty1>::_Call(static_cast<_Callable&&>(_Obj), static_cast<_Ty1&&>(_Arg1), static_cast<_Types2&&>(_Args2)...)) {if constexpr (_Invoker1<_Callable, _Ty1>::_Strategy == _Invoker_strategy::_Functor) {return static_cast<_Callable&&>(_Obj)(static_cast<_Ty1&&>(_Arg1), static_cast<_Types2&&>(_Args2)...);} else if constexpr (_Invoker1<_Callable, _Ty1>::_Strategy == _Invoker_strategy::_Pmf_object) {return (static_cast<_Ty1&&>(_Arg1).*_Obj)(static_cast<_Types2&&>(_Args2)...);} else if constexpr (_Invoker1<_Callable, _Ty1>::_Strategy == _Invoker_strategy::_Pmf_refwrap) {return (_Arg1.get().*_Obj)(static_cast<_Types2&&>(_Args2)...);} else if constexpr (_Invoker1<_Callable, _Ty1>::_Strategy == _Invoker_strategy::_Pmf_pointer) {return ((*static_cast<_Ty1&&>(_Arg1)).*_Obj)(static_cast<_Types2&&>(_Args2)...);} else if constexpr (_Invoker1<_Callable, _Ty1>::_Strategy == _Invoker_strategy::_Pmd_object) {return static_cast<_Ty1&&>(_Arg1).*_Obj;} else if constexpr (_Invoker1<_Callable, _Ty1>::_Strategy == _Invoker_strategy::_Pmd_refwrap) {return _Arg1.get().*_Obj;} else {static_assert(_Invoker1<_Callable, _Ty1>::_Strategy == _Invoker_strategy::_Pmd_pointer, "bug in invoke");return (*static_cast<_Ty1&&>(_Arg1)).*_Obj;}
}

從上面的代碼可以看到，傳入參數 _Obj 的型別判斷是通過類 _Invoker1 萃取出來的，那現在來看一下_Invoker1的廬山真面目吧：

//【1】
template <class _Callable, class _Ty1, class _Removed_cvref = _Remove_cvref_t<_Callable>,bool _Is_pmf = is_member_function_pointer_v<_Removed_cvref>,bool _Is_pmd = is_member_object_pointer_v<_Removed_cvref>>
struct _Invoker1;//【2】
template <class _Callable, class _Ty1, class _Removed_cvref>
struct _Invoker1<_Callable, _Ty1, _Removed_cvref, true, false>: conditional_t<is_base_of_v<typename _Is_memfunptr<_Removed_cvref>::_Class_type, remove_reference_t<_Ty1>>,_Invoker_pmf_object,conditional_t<_Is_specialization_v<_Remove_cvref_t<_Ty1>, reference_wrapper>, _Invoker_pmf_refwrap,_Invoker_pmf_pointer>> {}; // pointer to member function//【3】
template <class _Callable, class _Ty1, class _Removed_cvref>
struct _Invoker1<_Callable, _Ty1, _Removed_cvref, false, true>: conditional_t<is_base_of_v<typename _Is_member_object_pointer<_Removed_cvref>::_Class_type, remove_reference_t<_Ty1>>,_Invoker_pmd_object,conditional_t<_Is_specialization_v<_Remove_cvref_t<_Ty1>, reference_wrapper>, _Invoker_pmd_refwrap,_Invoker_pmd_pointer>> {}; // pointer to member data//【4】
template <class _Callable, class _Ty1, class _Removed_cvref>
struct _Invoker1<_Callable, _Ty1, _Removed_cvref, false, false> : _Invoker_functor {};

1）在【1】處通過?is_member_function_pointer_v 判斷是類成員函數指針，通過?is_member_object_pointer_v 判斷是類成員變量

2）在【2】處指示的的是類成員函數指針，判斷參數_Arg1是否為reference_wrapper類型的，即是傳入對象添加了std::ref或std::cref包裝。

3）在【3】處指示的是類成員變量指針，判斷參數_Arg1是否為reference_wrapper類型的，即是傳入對象添加了std::ref或std::cref包裝。

4）在【4】處指示的是除【2】，【3】之外的函數。

型別推導出的類型有：

enum class _Invoker_strategy {_Functor,   //普通函數，仿函數，lamdba表達式, std::function等_Pmf_object, //類成員函數，傳遞的是對象_Pmf_refwrap, //類成員函數，傳遞的是用std::ref或std::cref包裝了的對象_Pmf_pointer, //類成員函數，傳遞的是對象的指針_Pmd_object,  //類成員變量，傳遞的是對象_Pmd_refwrap, //類成員變量，傳遞的是用std::ref或std::cref包裝了的對象_Pmd_pointer  //類成員變量，傳遞的是對象的指針
};

至此，std::invoke的實現原理很清晰了吧。