std::apply — cppreference.com

Материал из cppreference.com

Определено в заголовочном файле `<tuple>`
`template< class F, class Tuple > constexpr decltype(auto) apply( F&& f, Tuple&& t );`		(начиная с C++17) (до C++23)
`template< class F, tuple-like Tuple > constexpr decltype(auto) apply( F&& f, Tuple&& t ) noexcept(/* смотрите ниже */);`		(начиная с C++23)

Вызывает Callable объект f элементами t в качестве аргументов.

Дана функция только для описания apply-impl, определённая следующим образом: template<class F, tuple-like Tuple, std::size_t... I> // нет ограничений на Tuple до C++23
constexpr decltype(auto)
apply-impl(F&& f, Tuple&& t, std::index_sequence<I...>) // только для описания
{
return INVOKE(std::forward<F>(f), std::get<I>(std::forward<Tuple>(t))...);
}

Эффект эквивалентен return apply-impl(std::forward<F>(f), std::forward<Tuple>(t),
std::make_index_sequence<
std::tuple_size_v<std::decay_t<Tuple>>>{}); .

Параметры

f	—	Callable объект для вызова
t	—	кортеж, элементы которого будут использоваться в качестве аргументов для `f`

Возвращаемое значение

Значение, возвращаемое f.

Исключения

(нет)

(до C++23)

спецификация

noexcept

noexcept( noexcept(std::invoke(std::forward<F>(f), std::get<Is>(std::forward<Tuple>(t))...)) )

где Is... обозначает пакет параметров:

0, 1, ..., std::tuple_size_v<std::remove_reference_t<Tuple>> - 1.

(начиная с C++23)

Примечание

`Tuple` не обязательно должен быть std::tuple, вместо него может быть любой объект, поддерживающий `std::get` и `std::tuple_size`; в частности, могут использоваться std::array и std::pair.	(до C++23)
`Tuple` должен быть tuple-подобным, т.е. каждый тип в нём должен быть специализацией std::tuple или другим типом (например, std::array и std::pair), который моделирует `tuple-like`.	(начиная с C++23)

Макрос Тестирования функциональности	Значение	Стандарт	Функциональность
`__cpp_lib_apply`	`201603L`	(C++17)	`std::apply`

Пример

#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()
{
    // OK
    std::cout << std::apply(add, std::pair(1, 2)) << '\n';
 
    // Ошибка: невозможно определить тип функции
    // 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'; 

    // расширенный пример
    std::tuple myTuple{25, "Привет", 9.31f, 'c'};
    std::cout << myTuple << '\n';
}

Вывод:

3
5
[25, Привет, 9.31, c]

Смотрите также

Категории: