# std::experimental::invocation_type, std::experimental::raw_invocation_type

From cppreference.com
< cpp‎ | experimental

Defined in header `<experimental/type_traits>` |  |
template< class > struct raw_invocation_type; //undefined template< class Fn, class... ArgTypes > struct raw_invocation_type<Fn(ArgTypes...)>; | (1) | (library fundamentals TS)
template< class > struct invocation_type; //undefined template< class Fn, class... ArgTypes > struct invocation_type<Fn(ArgTypes...)>; | (2) | (library fundamentals TS)

Computes the invocation parameters when `Fn` is called with the arguments `ArgTypes...`, as in INVOKE(std::declval<Fn>(), std::declval<ArgTypes>()...), where INVOKE is the operation defined in Callable.

The invocation parameters of the expression INVOKE(f, t1, t2, ..., tN) is defined as follows, where `T1` is the (possibly cv-qualified) type of `t1` and `U1` is `T1&` if `t1` is an lvalue and `T1&&` otherwise:

- If `f` is a pointer to a member function of a class `T`, then the invocation parameters are `U1` followed by the parameters of `f` matched by `t2, ..., tN`.
- If `N == 1` and `f` is a pointer to member data of a class `T`, then the invocation parameter is `U1`.
- If `f` is an object of class type, the invocation parameters are the parameters matching `t1, ..., tN` of the best viable function for the arguments `t1, ..., tN` among the function call operators and surrogate call functions of `f`.
- In all other cases, the invocations parameters are the parameters of `f` matching `t1, ..., tN`.

If an argument `tI` matches an ellipsis in the function's parameter list, the corresponding invocation parameter is the result of applying the default argument promotions to `tI`.

`Fn` and all types in `ArgTypes` can be any complete type, array of unknown bound, or (possibly cv-qualified) `void`.

### Member types

Member type | Definition
raw_invocation_type<Fn(ArgTypes...)>::type | R(T1, T2, ...), where: `R` is std::result_of_t<Fn(ArgTypes...)>. `T1, T2, ...` are the invocation parameters of INVOKE(std::declval<Fn>(), std::declval<ArgTypes>()...) as defined above. Only defined if `Fn` can be called with the arguments `ArgTypes...` in unevaluated context.
invocation_type<Fn(ArgTypes...)>::type | R(U1, U2, ...), where `R` is std::result_of_t<Fn(ArgTypes...)>. `T1, T2, ...` are the invocation parameters of INVOKE(std::declval<Fn>(), std::declval<ArgTypes>()...) as defined above. `A1, A2, ...` denotes `ArgTypes...` `Ui` is std::decay_t<Ai> if std::declval<Ai>() is an rvalue and `Ti` otherwise. Only defined if `Fn` can be called with the arguments `ArgTypes...` in unevaluated context.

### Helper types

template< class T > using raw_invocation_type_t = typename raw_invocation_type<T>::type; |  | (library fundamentals TS)
template< class T > using invocation_type_t = typename invocation_type<T>::type; |  | (library fundamentals TS)

### Example

| This section is incomplete Reason: no example

### See also

C++ documentation for Reflection TS

Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/experimental/invocation_type&oldid=154971"