# 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

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