std:: result_of, std:: invoke_result

Выводит тип возвращаемого значения INVOKE выражения на этапе компиляции.

Если программа добавляет специализации для любых шаблонов, описанных на этой странице, поведение не определено.

Типы членов

Вспомогательные типы

Возможная реализация

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>::значение>::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>::значение>::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>::значение>::type,
            class = typename std::enable_if<!is_reference_wrapper<Td>::значение>::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>::значение>::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>::вызов(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 обладает рядом особенностей, которые привели к его устареванию в пользу std::invoke_result в C++17:

• 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)
    {
        /* реализация */
    }

Примечания

Примеры

#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

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