std::invoke, std::invoke_r - cppreference.com (original) (raw)

Defined in header
template< class F, class... Args > std::invoke_result_t<F, Args...> invoke( F&& f, Args&&... args ) noexcept(/* see below */);	(1)	(since C++17) (constexpr since C++20)
template< class R, class F, class... Args > constexpr R invoke_r( F&& f, Args&&... args ) noexcept(/* see below */);	(2)	(since C++23)

1 Parameters
2 Return value
3 Exceptions
4 Possible implementation
5 Notes
6 Example
7 See also

[edit] Parameters

f	-	Callable object to be invoked
args	-	arguments to pass to f

[edit] Return value

The value returned by f.
The value returned by f, implicitly converted to R, if R is not (possibly cv-qualified) void. None otherwise.

[edit] Exceptions

[edit] Possible implementation

invoke (1)
namespace detail { template<class> constexpr bool is_reference_wrapper_v = false; template<class U> constexpr bool is_reference_wrapper_v<std::reference_wrapper<U>> = true; template<class T> using remove_cvref_t = std::remove_cv_t<std::remove_reference_t<T>>; template<class C, class Pointed, class Object, class... Args> constexpr decltype(auto) invoke_memptr(Pointed C::* member, Object&& object, Args&&... args) { using object_t = remove_cvref_t<Object>; constexpr bool is_member_function = std::is_function_v<Pointed>; constexpr bool is_wrapped = is_reference_wrapper_v<object_t>; constexpr bool is_derived_object = std::is_same_v<C, object_t> \|
invoke_r (2)
template<class R, class F, class... Args> requires std::is_invocable_r_v<R, F, Args...> constexpr R invoke_r(F&& f, Args&&... args) noexcept(std::is_nothrow_invocable_r_v<R, F, Args...>) { if constexpr (std::is_void_v<R>) std::invoke(std::forward<F>(f), std::forward<Args>(args)...); else return std::invoke(std::forward<F>(f), std::forward<Args>(args)...); }

[edit] Notes

Feature-test macro	Value	Std	Feature
__cpp_lib_invoke	201411L	(C++17)	std::invoke, (1)
__cpp_lib_invoke_r	202106L	(C++23)	std::invoke_r, (2)

[edit] Example

#include #include #include 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::cout << "invoke a free function: "; std::invoke(print_num, -9); std::cout << "invoke a lambda: "; std::invoke({ print_num(42); }); std::cout << "invoke a member function: "; const Foo foo(314159); std::invoke(&Foo::print_add, foo, 1); std::cout << "invoke (i.e., access) a data member num_: " << std::invoke(&Foo::num_, foo) << '\n'; std::cout << "invoke a function object: "; std::invoke(PrintNum(), 18); #if defined(__cpp_lib_invoke_r) auto add = [](int x, int y){ return x + y; }; std::cout << "invoke a lambda converting result to float: "; auto ret = std::invoke_r(add, 11, 22); static_assert(std::is_same<decltype(ret), float>()); std::cout << std::fixed << ret << "\ninvoke print_num: "; std::invoke_r(print_num, 44); #endif }

Possible output:

invoke a free function: -9 invoke a lambda: 42 invoke a member function: 314160 invoke (i.e., access) a data member num_: 314159 invoke a function object: 18 invoke a lambda converting result to float: 33.000000 invoke print_num: 44