std::invoke, std::invoke_r

헤더 `<functional>`
template< class F, class... Args > std::invoke_result_t<F, Args...> invoke( F&& f, Args&&... args ) noexcept(/* see below */);	에 정의됨 (1)	(C++17부터) (C++20부터 constexpr)
template< class R, class F, class... Args > constexpr R invoke_r( F&& f, Args&&... args ) noexcept(/* see below */);	(2)	(C++23부터)

1) Callable 객체 f를 매개변수 args로 INVOKE(std::forward<F>(f), std::forward<Args>(args)...)에 의해 호출합니다. 이 오버로드는 std::is_invocable_v<F, Args...>이(가) true인 경우에만 오버로드 해결에 참여합니다.

2) Callable 객체 f를 매개변수 args로 INVOKE<R>(std::forward<F>(f), std::forward<Args>(args)...)에 의해 호출합니다. 이 오버로드는 std::is_invocable_r_v<R, F, Args...>이(가) true인 경우에만 오버로드 해결에 참여합니다.

매개변수

f	-	Callable 호출될 객체
args	-	f 에 전달할 인수들

반환값

1) f 가 반환하는 값.

2) f 가 반환하는 값,

이 (가능성이 있는 cv-qualified ) void 가 아닌 경우

로 암시적으로 변환됨. 그렇지 않으면 없음.

예외

1)

noexcept 명세:

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

2)

noexcept 명세:

noexcept ( std:: is_nothrow_invocable_r_v < R, F, Args... > )

가능한 구현

invoke (1)

namespace detail
{
    template<class>
    constexpr bool is_reference_wrapper_v = false;
    template<class U>
    constexpr bool is_reference_wrapper_v<std::reference_wrapper<U>> = true;
    template<class T>
    using remove_cvref_t = std::remove_cv_t<std::remove_reference_t<T>>;
    template<class C, class Pointed, class Object, class... Args>
    constexpr decltype(auto) invoke_memptr(Pointed C::* member, Object&& object,
                                           Args&&... args)
    {
        using object_t = remove_cvref_t<Object>;
        constexpr bool is_member_function = std::is_function_v<Pointed>;
        constexpr bool is_wrapped = is_reference_wrapper_v<object_t>;
        constexpr bool is_derived_object = std::is_same_v<C, object_t>
                                        || std::is_base_of_v<C, object_t>;
        if constexpr (is_member_function)
        {
            if constexpr (is_derived_object)
                return (std::forward<Object>(object) .* member)
                           (std::forward<Args>(args)...);
            else if constexpr (is_wrapped)
                return (object.get() .* member)(std::forward<Args>(args)...);
            else
                return ((*std::forward<Object>(object)) .* member)
                           (std::forward<Args>(args)...);
        }
        else
        {
            static_assert(std::is_object_v<Pointed> && sizeof...(args) == 0);
            if constexpr (is_derived_object)
                return std::forward<Object>(object) .* member;
            else if constexpr (is_wrapped)
                return object.get() .* member;
            else
                return (*std::forward<Object>(object)) .* member;
        }
    }
} // 네임스페이스 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...>)
{
    if constexpr (std::is_member_pointer_v<detail::remove_cvref_t<F>>)
        return detail::invoke_memptr(f, std::forward<Args>(args)...);
    else
        return std::forward<F>(f)(std::forward<Args>(args)...);
}

invoke_r (2)

template<class R, class F, class... Args>
    requires std::is_invocable_r_v<R, F, Args...>
constexpr R invoke_r(F&& f, Args&&... args)
    noexcept(std::is_nothrow_invocable_r_v<R, F, Args...>)
{
    if constexpr (std::is_void_v<R>)
        std::invoke(std::forward<F>(f), std::forward<Args>(args)...);
    else
        return std::invoke(std::forward<F>(f), std::forward<Args>(args)...);
}

참고 사항

기능 테스트 매크로	값	표준	기능
`__cpp_lib_invoke`	`201411L`	(C++17)	`std::invoke` , ( 1 )
`__cpp_lib_invoke_r`	`202106L`	(C++23)	`std::invoke_r` , ( 2 )

예제

이 코드 실행

#include <functional>
#include <iostream>
#include <type_traits>
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::cout << "invoke a free function: ";
    std::invoke(print_num, -9);
    std::cout << "invoke a lambda: ";
    std::invoke([](){ print_num(42); });
    std::cout << "invoke a member function: ";
    const Foo foo(314159);
    std::invoke(&Foo::print_add, foo, 1);
    std::cout << "invoke (i.e., access) a data member num_: "
              << std::invoke(&Foo::num_, foo) << '\n';
    std::cout << "invoke a function object: ";
    std::invoke(PrintNum(), 18);
#if defined(__cpp_lib_invoke_r)
    auto add = [](int x, int y){ return x + y; };
    std::cout << "invoke a lambda converting result to float: ";
    auto ret = std::invoke_r<float>(add, 11, 22);
    static_assert(std::is_same<decltype(ret), float>());
    std::cout << std::fixed << ret << "\ninvoke print_num: ";
    std::invoke_r<void>(print_num, 44);
#endif
}

가능한 출력:

invoke a free function: -9
invoke a lambda: 42
invoke a member function: 314160
invoke (i.e., access) a data member num_: 314159
invoke a function object: 18
invoke a lambda converting result to float: 33.000000
invoke print_num: 44

참고 항목

mem_fn (C++11)	멤버 포인터로부터 함수 객체를 생성함 (함수 템플릿)
result_of invoke_result (C++11) (C++20에서 제거됨) (C++17)	호출 가능 객체를 인수 집합으로 호출한 결과 타입을 추론함 (클래스 템플릿)
is_invocable is_invocable_r is_nothrow_invocable is_nothrow_invocable_r (C++17)	타입이 주어진 인수 타입들로 호출 가능한지 확인함 ( std::invoke 로 호출하는 것처럼) (클래스 템플릿)
apply (C++17)	튜플 인수로 함수를 호출함 (함수 템플릿)

컴파일러 지원
프리스탠딩 및 호스팅
언어
표준 라이브러리
표준 라이브러리 헤더
명명된 요구 사항
기능 테스트 매크로 (C++20)
언어 지원 라이브러리
개념 라이브러리 (C++20)
진단 라이브러리
메모리 관리 라이브러리
메타프로그래밍 라이브러리 (C++11)
일반 유틸리티 라이브러리
컨테이너 라이브러리
반복자 라이브러리
범위 라이브러리 (C++20)
알고리즘 라이브러리
문자열 라이브러리
텍스트 처리 라이브러리
수치 라이브러리
날짜 및 시간 라이브러리
입출력 라이브러리
파일 시스템 라이브러리 (C++17)
동시성 지원 라이브러리 (C++11)
실행 제어 라이브러리 (C++26)
기술 명세
기호 인덱스
외부 라이브러리

ko.cppreference.net

Namespaces

Variants

std::invoke, std::invoke_r

목차

매개변수

반환값

예외

가능한 구현

참고 사항

예제

참고 항목