std::invoke

De cppreference.com

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)

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)).

Contenido

[editar] Parámetros

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

[editar] Excepciones

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

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

[editar] 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)...);
}

[editar] 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

[editar] Véase también

mem_fn (C++11)	Crea un objeto función de un puntero a un miembro. (plantilla de función) [editar]
result_of (C++11)	Deduce el tipo de retorno de una expresión de llamada a la función. (plantilla de clase) [editar]
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) [editar]
apply (C++17)	Llama a una función con una tupla de argumentos. (plantilla de función) [editar]

Obtenido de «https://es.cppreference.com/mwiki/index.php?title=cpp/utility/functional/invoke&oldid=43456»

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

cppreference.com

Espacios de nombres

Variantes

Vistas

Acciones