Namespaces
Variants

    std::apply

    С сайта ru.cppreference.net
     
    C++
    Поддержка компиляторов
    Автономное и размещённое
    Язык
    Стандартная библиотека
    Заголовки стандартной библиотеки
    Именованные требования
    Макросы проверки возможностей (C++20)
    Библиотека поддержки языка
    Библиотека концепций (C++20)
    Библиотека диагностики
    Библиотека управления памятью
    Библиотека метапрограммирования (C++11)
    Библиотека общих утилит
    Библиотека контейнеров
    Библиотека итераторов
    Библиотека диапазонов (C++20)
    Библиотека алгоритмов
    Библиотека строк
    Библиотека обработки текста
    Библиотека численных операций
    Библиотека даты и времени
    Библиотека ввода/вывода
    Библиотека файловой системы (C++17)
    Библиотека поддержки параллелизма (C++11)
    Библиотека управления выполнением (C++26)
    Технические спецификации
    Индекс символов
    Внешние библиотеки
     
    Библиотека утилит
    Поддержка языка
    Поддержка типов (основные типы, RTTI)
    Макросы проверки возможностей библиотеки (C++20)
    Утилиты программы
    Функции с переменным числом аргументов
    (C++11)
    (C++20)
    (C++26)
    (C++20)
    Поддержка корутин (C++20)
    Поддержка контрактов (C++26)
    Трёхстороннее сравнение
    (C++20)(C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)    
    (C++20)(C++20)(C++20)    
    (C++20)(C++20)(C++20)

    Общие утилиты
    Операторы отношений (устарело в C++20)
    Функции сравнения целых чисел
    (C++20)(C++20)(C++20)    
    (C++20)
    Операции обмена и типов
    (C++20)
    (C++14)
    (C++11)
    (C++23)
    (C++11)
    (C++23)
    (C++11)
    (C++11)
    (C++17)
    Общеупотребительные типы лексики
    (C++11)
    (C++17)
    (C++17)
    (C++17)
    (C++11)
    (C++11)
    (C++17)
    (C++17)
    (C++23)



     
    Определён в заголовочном файле <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(/* see below */);
    		(начиная с C++23)

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

    Учитывая функцию, определённую только для пояснения, apply-impl, определённую следующим образом:

    template<class F,class Tuple, std::size_t... I>
    constexpr decltype(auto)
        apply-impl(F&& f, Tuple&& t, std::index_sequence<I...>) // exposition only
    {
        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... обозначает пакет :

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

    Примечания

    Tuple не обязательно должен быть std::tuple , вместо этого может быть любым типом, который поддерживает std::get и std::tuple_size ; в частности, могут использоваться std::array и std::pair .

    		(до C++23)

    Tuple ограничен требованием быть tuple-like, т.е. каждый тип должен быть специализацией 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, "Hello", 9.31f, 'c'};
    std::cout << myTuple << '\n';
}

    Вывод: 

    3
5
[25, Hello, 9.31, c]

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

    (C++11)
    		создает объект tuple типа, определенного типами аргументов
    (шаблон функции)
    (C++11)
    		создает tuple из forwarding references
    (шаблон функции)
    (C++17)
    		создает объект с кортежем аргументов
    (шаблон функции)
    (C++17) (C++23)
    		вызывает любой Callable объект с заданными аргументами и возможностью указания типа возвращаемого значения (since C++23)
    (шаблон функции)