Namespaces
Variants

std:: result_of, std:: invoke_result

From cppreference.net
C++
Metaprogramming library
Type traits
Type categories
(C++11)
(C++11) ( DR* )
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Type properties
(C++11)
(C++11)
(C++11)
(C++11)
(C++14)
(C++11)
(C++17)
(C++23)
(C++11) (deprecated in C++26)
(C++11)
(C++11)
(C++11) ( until C++20* )
(C++11) (deprecated in C++20)
(C++11)
(C++11)
(C++20)
(C++20)
(C++23)
(C++17)
Type trait constants
(C++11) (C++17) (C++11) (C++11)
Metafunctions
(C++17)
(C++17)
(C++17)
Supported operations
Relationships and property queries
Type modifications
Type transformations
(C++11) (deprecated in C++23)
(C++11) (deprecated in C++23)
(C++11)
(C++20)
result_of invoke_result
(C++11) ( until C++20* ) (C++17)

Compile-time rational arithmetic
Compile-time integer sequences
(C++14)
ヘッダーで定義 <type_traits>
template < class >

class result_of ; // 未定義

template < class F, class ... ArgTypes >

class result_of < F ( ArgTypes... ) > ;
(1) (C++11以降)
(C++17で非推奨)
(C++20で削除)
template < class F, class ... ArgTypes >
class invoke_result ;
(2) (C++17以降)

コンパイル時に INVOKE 式 の戻り値の型を推論します。

F は呼び出し可能な型、関数への参照、または呼び出し可能な型への参照でなければなりません。 F を ArgTypes... で呼び出すことは、適切な式でなければなりません。

(C++11以降)
(C++14まで)

F および ArgTypes 内のすべての型は、任意の完全型、未知の境界を持つ配列、または（CV修飾された可能性のある） void とすることができます。

(C++14以降)

プログラムがこのページで説明されているテンプレートのいずれかに対して特殊化を追加する場合、動作は未定義です。

目次

メンバー型

メンバー型 定義
type Callable 型 F が引数 ArgTypes... で呼び出された場合の戻り値の型。 Fが未評価コンテキストで引数 ArgTypes... で呼び出せる場合にのみ定義される。 (C++14以降)

ヘルパー型

template < class T >
using result_of_t = typename result_of < T > :: type ;
(1) (C++14で追加)
(C++17で非推奨)
(C++20で削除)
template < class F, class ... ArgTypes >
using invoke_result_t = typename invoke_result < F, ArgTypes... > :: type ;
(2) (C++17で追加)

実装例 

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>
    struct invoke_impl
    {
        template<class F, class... Args>
        static auto call(F&& f, Args&&... args)
            -> decltype(std::forward<F>(f)(std::forward<Args>(args)...));
    };
    template<class B, class MT>
    struct invoke_impl<MT B::*>
    {
        template<class T, class Td = typename std::decay<T>::type,
            class = typename std::enable_if<std::is_base_of<B, Td>::value>::type>
        static auto get(T&& t) -> T&&;
        template<class T, class Td = typename std::decay<T>::type,
            class = typename std::enable_if<is_reference_wrapper<Td>::value>::type>
        static auto get(T&& t) -> decltype(t.get());
        template<class T, class Td = typename std::decay<T>::type,
            class = typename std::enable_if<!std::is_base_of<B, Td>::value>::type,
            class = typename std::enable_if<!is_reference_wrapper<Td>::value>::type>
        static auto get(T&& t) -> decltype(*std::forward<T>(t));
        template<class T, class... Args, class MT1,
            class = typename std::enable_if<std::is_function<MT1>::value>::type>
        static auto call(MT1 B::*pmf, T&& t, Args&&... args)
            -> decltype((invoke_impl::get(
                std::forward<T>(t)).*pmf)(std::forward<Args>(args)...));
        template<class T>
        static auto call(MT B::*pmd, T&& t)
            -> decltype(invoke_impl::get(std::forward<T>(t)).*pmd);
    };
    template<class F, class... Args, class Fd = typename std::decay<F>::type>
    auto INVOKE(F&& f, Args&&... args)
        -> decltype(invoke_impl<Fd>::call(std::forward<F>(f),
            std::forward<Args>(args)...));
} // namespace detail
// 最小限のC++11実装:
template<class> struct result_of;
template<class F, class... ArgTypes>
struct result_of<F(ArgTypes...)>
{
    using type = decltype(detail::INVOKE(std::declval<F>(), std::declval<ArgTypes>()...));
};
// C++14準拠の実装（有効なC++11実装でもあります）:
namespace detail
{
    template<typename AlwaysVoid, typename, typename...>
    struct invoke_result {};
    template<typename F, typename...Args>
    struct invoke_result<
        decltype(void(detail::INVOKE(std::declval<F>(), std::declval<Args>()...))),
            F, Args...>
    {
        using type = decltype(detail::INVOKE(std::declval<F>(), std::declval<Args>()...));
    };
} // namespace detail
template<class> struct result_of;
template<class F, class... ArgTypes>
struct result_of<F(ArgTypes...)> : detail::invoke_result<void, F, ArgTypes...> {};
template<class F, class... ArgTypes>
struct invoke_result : detail::invoke_result<void, F, ArgTypes...> {};

注記

C++11で規定された通り、 std::result_of の動作は、 INVOKE(std::declval<F>(), std::declval<ArgTypes>()...) が不適格な場合（例えばFが全く呼び出し可能な型でない場合）に未定義です。C++14ではこれを SFINAE に変更しました（Fが呼び出し可能でない場合、 std::result_of<F(ArgTypes...)> は単に type メンバを持ちません）。

std::result_of の動機は、 Callable の呼び出し結果を判定することにあり、特にその結果型が引数の組によって異なる場合に有用です。

F ( Args... ) は、 Args... が引数型で F が戻り値型である関数型です。このため、 std::result_of にはいくつかの特異な動作があり、C++17では std::invoke_result を優先する形で非推奨となりました：

  • F は関数型または配列型ではならない（ただしそれらへの参照型は可能）；
  • Args のいずれかが「 T の配列」型または関数型 T を持つ場合、自動的に T* に調整される；
  • F および Args... のいずれも抽象クラス型であってはならない；
  • Args... のいずれかにトップレベルのcv修飾子が付いている場合、それは破棄される；
  • Args... のいずれも void 型であってはならない。

これらの特異な動作を避けるため、 result_of は参照型と共に使用されることが多く、例えば F および Args... として使用されます： 

template<class F, class... Args>
std::result_of_t<F&&(Args&&...)> // 誤りである std::result_of_t<F(Args...)> の代わりに
    my_invoke(F&& f, Args&&... args)
    {
        /* 実装 */
    }

注記

機能テスト マクロ 値 標準 機能
__cpp_lib_result_of_sfinae 201210L (C++14) std::result_of と SFINAE
__cpp_lib_is_invocable 201703L (C++17) std::is_invocable , std::invoke_result

例

このコードを実行 
#include <iostream>
#include <type_traits>
struct S
{
    double operator()(char, int&);
    float operator()(int) { return 1.0; }
};
template<class T>
typename std::result_of<T(int)>::type f(T& t)
{
    std::cout << "overload of f for callable T\n";
    return t(0);
}
template<class T, class U>
int f(U u)
{
    std::cout << "overload of f for non-callable T\n";
    return u;
}
int main()
{
    // Sをcharとint&引数で呼び出した結果の型はdouble
    std::result_of<S(char, int&)>::type d = 3.14; // dの型はdouble
    static_assert(std::is_same<decltype(d), double>::value, "");
    // std::invoke_resultは異なる構文を使用（括弧なし）
    std::invoke_result<S,char,int&>::type b = 3.14;
    static_assert(std::is_same<decltype(b), double>::value, "");
    // Sをint引数で呼び出した結果の型はfloat
    std::result_of<S(int)>::type x = 3.14; // xの型はfloat
    static_assert(std::is_same<decltype(x), float>::value, "");
    // result_ofはメンバ関数ポインタと共に以下のように使用可能
    struct C { double Func(char, int&); };
    std::result_of<decltype(&C::Func)(C, char, int&)>::type g = 3.14;
    static_assert(std::is_same<decltype(g), double>::value, "");
    f<C>(1); // C++11ではコンパイル失敗の可能性あり; C++14では非呼び出し可能オーバーロードを呼び出し
}

出力: 

overload of f for non-callable T

関連項目

(C++17) (C++23)
任意の Callable オブジェクトを指定された引数で呼び出し 戻り値の型を指定可能 (C++23以降)
(関数テンプレート)
(C++17)
型が指定された引数型で呼び出し可能かどうかチェックする ( std::invoke による呼び出しとして)
(クラステンプレート)
(C++11)
未評価コンテキストで使用するためのテンプレート型引数のオブジェクトへの参照を取得する
(関数テンプレート)