# std::apply

< cpp‎ | utility

定义于头文件 `<tuple>` |  |
template <class F, class Tuple> constexpr decltype(auto) apply(F&& f, Tuple&& t); |  | (C++17 起)

以参数的元组调用可调用 (Callable) 对象 `f` 。

### 参数

f | - | 要调用的可调用 (Callable) 对象
t | - | 以其元素为 `f` 的参数的元组

### 返回值

`f` 所返回的值。

### 注解

元组不必是 std::tuple ，可以为任何支持 std::get 和 std::tuple_size 的类型所替代；特别是可以用 std::array 和 std::pair 。

### 可能的实现

    namespace detail {
    template <class F, class Tuple, std::size_t... I>
    constexpr decltype(auto) apply_impl(F&& f, Tuple&& t, std::index_sequence<I...>)
    {
        // 此实现从 C++20 起合法（经由 P1065R2 ）
        // C++17 中，实际上在此需要 std::invoke 的 constexpr 对应
        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>>>{});
    }

### 示例

    #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]

### 参阅

make_tuple | 创建一个 `tuple` 对象，其类型根据各实参类型定义 (函数模板)
forward_as_tuple | 创建转发引用的 `tuple` (函数模板)
make_from_tuple (C++17) | 以一个实参元组构造对象 (函数模板)
invoke invoke_r (C++17)(C++23) | 以给定实参和可能指定的返回类型 (C++23 起)调用任意可调用 (Callable) 对象 (函数模板)