std::apply - cppreference.com (original) (raw)

| Defined in header | | | | ----------------------------------------------------------------------------------------------------------------------- | | --------------------------- | | template< class F, class Tuple > constexpr decltype(auto) apply( F&& f, Tuple&& t ); | | (since C++17) (until C++23) | | template< class F, tuple-like Tuple > constexpr decltype(auto) apply( F&& f, Tuple&& t ) noexcept(/* see below */); | | (since C++23) |

Invoke the Callable object f with the elements of t as arguments.

Given the exposition-only function _apply-impl_ defined as follows:

template<class F,class Tuple, std::size_t... I>
constexpr decltype(auto)
`_apply-impl_`(F&& f, Tuple&& t, [std::index\_sequence](integer%5Fsequence.html)<I...\>) // exposition only `{` return INVOKE(std::forward<F>(f), std::get<I>(std::forward<Tuple>(t))...);
}

The effect is equivalent to:

return _apply-impl_(std::forward<F>(f), std::forward<Tuple>(t),
[std::make\_index\_sequence](integer%5Fsequence.html)< std::tuple_size_v<std::decay_t<Tuple>>>{}); .

[edit] Parameters

[edit] Return value

The value returned by f.

[edit] Exceptions

[edit] Notes

[edit] Example

#include #include #include   int add(int first, int second) { return first + second; }   template T add_generic(T first, T second) { return first + second; }   auto add_lambda = [](auto first, auto second) { return first + second; };   template<typename... Ts> std::ostream& operator<<(std::ostream& os, std::tuple<Ts...> const& theTuple) { std::apply ( [&os](Ts const&... tupleArgs) { os << '['; std::size_t n{0}; ((os << tupleArgs << (++n != sizeof...(Ts) ? ", " : "")), ...); os << ']'; }, theTuple ); return os; }   int main() { // OK std::cout << std::apply(add, std::pair(1, 2)) << '\n';   // Error: can't deduce the function type // std::cout << std::apply(add_generic, std::make_pair(2.0f, 3.0f)) << '\n';   // OK std::cout << std::apply(add_lambda, std::pair(2.0f, 3.0f)) << '\n';   // advanced example std::tuple myTuple{25, "Hello", 9.31f, 'c'}; std::cout << myTuple << '\n'; }

Output:

[edit] See also