std::apply
De cppreference.com
| Definido en el archivo de encabezado <tuple>
|
||
| template <class F, class Tuple> constexpr decltype(auto) apply(F&& f, Tuple&& t); |
(desde C++17) | |
Invoca al objeto invocable (Callable) f con una tupla de argumentos.
Contenido |
[editar] Parámetros
| f | - | El objeto invocable (Callable) a ser invocado. |
| t | - | Tupla cuyos elementos serán usados como argumentos para f.
|
[editar] Valor de retorno
El valor devuelto por f.
[editar] Notas
La tupla no tiene que ser necesariamente std::tuple, y en su lugar puede ser cualquier cosa que soporte std::get y std::tuple_size; en particular, pueden usarse std::array y std::pair.
[editar] Posible implementación
namespace detail { template <class F, class Tuple, std::size_t... I> constexpr decltype(auto) apply_impl(F&& f, Tuple&& t, std::index_sequence<I...>) { // Esta implementación es válida desde C++20 (vía P1065R2) // En C++17, aquí se necesita una contraparte constexpr de std::invoke return std::invoke(std::forward<F>(f), std::get<I>(std::forward<Tuple>(t))...); } } // namespace detail template <class F, class Tuple> constexpr decltype(auto) apply(F&& f, Tuple&& t) { return detail::apply_impl( std::forward<F>(f), std::forward<Tuple>(t), std::make_index_sequence<std::tuple_size_v<std::remove_reference_t<Tuple>>>{}); } |
[editar] Ejemplo
Ejecuta este código
#include <iostream> #include <tuple> #include <utility> int add(int first, int second) { return first + second; } template<typename T> 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() { // de acuerdo std::cout << std::apply(add, std::pair(1, 2)) << '\n'; // ERROR: no puede deducirse el tipo de función // std::cout << std::apply(add_generic, std::make_pair(2.0f, 3.0f)) << '\n'; // de acuerdo std::cout << std::apply(add_lambda, std::pair(2.0f, 3.0f)) << '\n'; // ejemplo avanzado std::tuple myTuple(25, "Hola", 9.31f, 'c'); std::cout << myTuple << '\n'; }
Salida:
3 5 [25, Hola, 9.31, c]
[editar] Véase también
| Crea un objeto de tupla del tipo definido por los tipos de argumentos. (plantilla de función) | |
| Crea una tupla de referencias r-valor. (plantilla de función) | |
| (C++17) |
Construye un objeto con una tupla de argumentos. (plantilla de función) |
| (C++17)(C++23) |
Invoca cualquier objeto Callable con los argumentos dados y la posibilidad de especificar el tipo de retorno. (desde C++23) (plantilla de función) |
