std::invoke

 

C++

Apoyo de compiladores

Implementaciones independientes y albergadas

Lenguaje

Biblioteca estándar

Encabezados de la biblioteca estándar

Requisitos denominados

Macros de prueba de característica (C++20)

Biblioteca de apoyo del lenguaje

Biblioteca de conceptos (C++20)

Biblioteca de diagnósticos

Biblioteca de gestión de memoria

Biblioteca de metaprogramación (C++11)

Biblioteca de servicios generales

Biblioteca de contenedores

Biblioteca de iteradores

Biblioteca de rangos (C++20)

Biblioteca de algoritmos

Biblioteca de cadenas

Biblioteca de procesamiento de texto

Biblioteca numérica

Biblioteca de fecha y hora

Biblioteca de entrada/salida

Biblioteca del sistema de archivos (C++17)

Biblioteca de apoyo de concurrencia (C++11)

Biblioteca de apoyo de ejecución (C++26)

Especificaciones técnicas

Índice de símbolos

Bibliotecas externas

 

Biblioteca de servicios

Apoyo del lenguaje Apoyo de tipos (tipos básicos, RTTI) Biblioteca de macros de prueba de característica (C++20) Servicios del programa Apoyo de corrutinas (C++20) Funciones variádicas is_constant_evaluated (C++20) is_within_lifetime (C++26) initializer_list (C++11) source_location (C++20) Comparación de tres vías three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20)   is_eqis_ltis_lteq (C++20)(C++20)(C++20)   is_neqis_gtis_gteq (C++20)(C++20)(C++20)

Servicios generales Objetos función Manipulación de bits (C++20) bitset hash (C++11) Operadores relacionales (en desuso en C++20) rel_ops::operator!=rel_ops::operator>    rel_ops::operator<=rel_ops::operator>= Funciones de comparación de enteros cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20)   cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) Intercambio y operaciones de tipos swap ranges::swap (C++20) exchange (C++14) declval (C++11) to_underlying (C++23) forward (C++11) forward_like (C++23) move (C++11) move_if_noexcept (C++11) as_const (C++17) Tipos vocabulario comunes pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) expected (C++23)

 

Objetos función

Envoltorios de funciones function (C++11) move_only_function (C++23) mem_fn (C++11) bad_function_call (C++11)	Aplicación parcial de funciones bind_front (C++20) bind (C++11) is_bind_expression (C++11) is_placeholder (C++11) _1, _2, _3, ... (C++11)
Invocación de funciones invokeinvoke_r (C++17)(C++23) Objeto función identidad identity (C++20)	Envoltorios de referencias reference_wrapper (C++11) refcref (C++11)(C++11) unwrap_referenceunwrap_ref_decay (C++20)(C++20)
Envoltorios de operadores plus minus negate multiplies divides modulus bit_and bit_or bit_not (C++14) bit_xor equal_to not_equal_to greater less greater_equal less_equal logical_and logical_or logical_not	Envoltorios de operador transparentes plus<> (C++14) minus<> (C++14) negate<> (C++14) multiplies<> (C++14) divides<> (C++14) modulus<> (C++14) bit_and<> (C++14) bit_or<> (C++14) bit_not<> (C++14) bit_xor<> (C++14) equal_to<> (C++14) not_equal_to<> (C++14) greater<> (C++14) less<> (C++14) greater_equal<> (C++14) less_equal<> (C++14) logical_and<> (C++14) logical_or<> (C++14) logical_not<> (C++14)
Negadores not_fn (C++17) Buscadores default_searcher (C++17) boyer_moore_searcher (C++17) boyer_moore_horspool_searcher (C++17)	Comparadores restringidos ranges::equal_to (C++20) ranges::not_equal_to (C++20) ranges::greater (C++20) ranges::less (C++20) ranges::greater_equal (C++20) ranges::less_equal (C++20) compare_three_way (C++20)
Vinculadores y adaptadores antiguos
unary_function (hasta C++17) binary_function (hasta C++17) ptr_fun (hasta C++17) pointer_to_unary_function (hasta C++17) pointer_to_binary_function (hasta C++17) mem_fun (hasta C++17) mem_fun_tmem_fun1_tconst_mem_fun_tconst_mem_fun1_t (hasta C++17)(hasta C++17)(hasta C++17)(hasta C++17) not1 (hasta C++20) not2 (hasta C++20)	binder1stbinder2nd (hasta C++17)(hasta C++17) bind1stbind2nd (hasta C++17)(hasta C++17) mem_fun_ref (hasta C++17) mem_fun_ref_tmem_fun1_ref_tconst_mem_fun_ref_tconst_mem_fun1_ref_t (hasta C++17)(hasta C++17)(hasta C++17)(hasta C++17) unary_negate (hasta C++20) binary_negate (hasta C++20)

 

<tbody> </tbody> <tbody class="t-dcl-rev "> </tbody><tbody> </tbody>

Definido en el archivo de encabezado <functional>
template< class F, class... Args> std::invoke_result_t<F, Args...> invoke(F&& f, Args&&... args) noexcept(/* véase más abajo */);		(desde C++17) (hasta C++20)
template< class F, class... Args> constexpr std::invoke_result_t<F, Args...> invoke(F&& f, Args&&... args) noexcept(/* véase más abajo */);		(desde C++20)

See More

Invoca al objeto Callable (invocable) f con los parámetros args como si fuera por INVOKE(std::forward<F>(f), std::forward<Args>(args)...).

Donde INVOKE(f, t1, t2, ..., tN) se define de la siguiente manera:

• Si f es un puntero a función miembro de clase T:

• Si std::is_base_of<T, std::decay_t<decltype(t1)>>::value es true, entonces INVOKE(f, t1, t2, ..., tN) es equivalente a (t1.*f)(t2, ..., tN).
• Si std::decay_t<decltype(t1)> es una especialización de std::reference_wrapper, entonces INVOKE(f, t1, t2, ..., tN) es equivalente a (t1.get().*f)(t2, ..., tN).
• Si t1 no satisface los puntos anteriores, entonces INVOKE(f, t1, t2, ..., tN) es equivalente a ((*t1).*f)(t2, ..., tN).

• De lo contrario, si N == 1 y f es un puntero a dato miembro de clase T:

• Si std::is_base_of<T, std::decay_t<decltype(t1)>>::value es true, entonces INVOKE(f, t1) es equivalente a t1.*f.
• Si std::decay_t<decltype(t1)> es una especialización de std::reference_wrapper, entonces INVOKE(f, t1) es equivalente a t1.get().*f.
• Si t1 no satisface los puntos anteriores, entonces INVOKE(f, t1) es equivalente a (*t1).*f.

• De lo contrario, INVOKE(f, t1, t2, ..., tN) es equivalente a f(t1, t2, ..., tN) (es decir, f es un FunctionObject (objeto función)).

Parámetros

f	-	Objeto Callable a ser invocado.
args	-	Argumentos a pasar a f.

Excepciones

Especificación noexcept:   (desde C++11)

<tbody> </tbody>

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

Posible implementación

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, 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)...);
}

Ejemplo

Ejecuta este código

#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()
{
    // invocar una función libre
    std::invoke(print_num, -9);

    // invocar una lambda
    std::invoke([]() { print_num(42); });

    // invocar una función miembro
    const Foo foo(314159);
    std::invoke(&Foo::print_add, foo, 1);
   
    // invocar (acceder) a un dato miembro
    std::cout << "num_: " << std::invoke(&Foo::num_, foo) << '\n';

    // invocar un objeto función
    std::invoke(PrintNum(), 18);
}

Salida:

-9
42
314160
num_: 314159
18

Véase también

mem_fn (C++11)	Crea un objeto función de un puntero a un miembro. (plantilla de función)
result_of (C++11)	Deduce el tipo de retorno de una expresión de llamada a la función. (plantilla de clase)
is_invocableis_invocable_ris_nothrow_invocableis_nothrow_invocable_r (C++17)	Comprueba si un tipo puede invocarse (como si lo fuera por std::invoke) con el número de argumentos dado. (plantilla de clase)
apply (C++17)	Llama a una función con una tupla de argumentos. (plantilla de función)