◐ Shell
clean mode source ↗

std::invoke - cppreference.com

提供: cppreference.com

<tbody> </tbody>

ヘッダ <functional> で定義

template< class F, class... Args> std::invoke_result_t<F, Args...> invoke(F&& f, Args&&... args) noexcept(/* see below */);

 (C++17以上)
(C++20未満)

template< class F, class... Args> constexpr std::invoke_result_t<F, Args...> invoke(F&& f, Args&&... args) noexcept(/* see below */);

 (C++20以上)

INVOKE(std::forward<F>(f), std::forward<Args>(args)...) によって行われたかのように、Callable なオブジェクト f を引数 args で呼び出します。

INVOKE(f, t1, t2, ..., tN) は以下のように定義されます。

  • std::is_base_of<T, std::decay_t<decltype(t1)>>::value が true であれば、 INVOKE(f, t1, t2, ..., tN) は (t1.*f)(t2, ..., tN) と同等です。
  • std::decay_t<decltype(t1)> が std::reference_wrapper の特殊化であれば、 INVOKE(f, t1, t2, ..., tN) は (t1.get().*f)(t2, ..., tN) と同等です。
  • t1 が上のいずれも満たさなければ、 INVOKE(f, t1, t2, ..., tN) は ((*t1).*f)(t2, ..., tN) と同等です。
  • std::is_base_of<T, std::decay_t<decltype(t1)>>::value が true であれば、 INVOKE(f, t1) は t1.*f と同等です。
  • std::decay_t<decltype(t1)> が std::reference_wrapper の特殊化であれば、 INVOKE(f, t1) は t1.get().*f と同等です。
  • t1 が上のいずれも満たさなければ、 INVOKE(f, t1) は (*t1).*f と同等です。
  • そうでなければ、 INVOKE(f, t1, t2, ..., tN) は f(t1, t2, ..., tN) と同等です (つまり、 f は FunctionObject です)。

引数

f - 呼ばれる Callable なオブジェクト
args - f に渡す引数

例外

noexcept

指定:  

noexcept(std::is_nothrow_invocable_v<F, Args...>)

実装例

namespace detail {
template <class T>
struct is_reference_wrapper : std::false_type {};
template <class U>
struct is_reference_wrapper<std::reference_wrapper<U>> : std::true_type {};
template <class T>
constexpr bool is_reference_wrapper_v = is_reference_wrapper<T>::value;

template <class T, class Type, class T1, class... Args>
constexpr decltype(auto) INVOKE(Type T::* f, T1&& t1, Args&&... args)
{
    if constexpr (std::is_member_function_pointer_v<decltype(f)>) {
        if constexpr (std::is_base_of_v<T, std::decay_t<T1>>)
            return (std::forward<T1>(t1).*f)(std::forward<Args>(args)...);
        else if constexpr (is_reference_wrapper_v<std::decay_t<T1>>)
            return (t1.get().*f)(std::forward<Args>(args)...);
        else
            return ((*std::forward<T1>(t1)).*f)(std::forward<Args>(args)...);
    } else {
        static_assert(std::is_member_object_pointer_v<decltype(f)>);
        static_assert(sizeof...(args) == 0);
        if constexpr (std::is_base_of_v<T, std::decay_t<T1>>)
            return std::forward<T1>(t1).*f;
        else if constexpr (is_reference_wrapper_v<std::decay_t<T1>>)
            return t1.get().*f;
        else
            return (*std::forward<T1>(t1)).*f;
    }
}

template <class F, class... Args>
constexpr decltype(auto) INVOKE(F&& f, Args&&... args)
{
      return std::forward<F>(f)(std::forward<Args>(args)...);
}
} // namespace detail

template< class F, class... Args>
constexpr std::invoke_result_t<F, Args...> invoke(F&& f, Args&&... args) 
  noexcept(std::is_nothrow_invocable_v<F, Args...>)
{
    return detail::INVOKE(std::forward<F>(f), std::forward<Args>(args)...);
}

例

#include <functional>
#include <iostream>

struct Foo {
    Foo(int num) : num_(num) {}
    void print_add(int i) const { std::cout << num_+i << '\n'; }
    int num_;
};

void print_num(int i)
{
    std::cout << i << '\n';
}

struct PrintNum {
    void operator()(int i) const
    {
        std::cout << i << '\n';
    }
};

int main()
{
    // 自由関数を呼びます。
    std::invoke(print_num, -9);

    // ラムダを呼びます。
    std::invoke([]() { print_num(42); });

    // メンバ関数を呼びます。
    const Foo foo(314159);
    std::invoke(&Foo::print_add, foo, 1);
   
    // データメンバを呼びます (アクセスします)。
    std::cout << "num_: " << std::invoke(&Foo::num_, foo) << '\n';

    // 関数オブジェクトを呼びます。
    std::invoke(PrintNum(), 18);
}

出力: 

-9
42
314160
num_: 314159
18

関連項目