Namespaces
Variants

std::move_only_function:: operator()

From cppreference.net
C++
Utilities library
Function objects
Function invocation
(C++17) (C++23)
Identity function object
(C++20)
Old binders and adaptors
( until C++17* )
( until C++17* )
( until C++17* )
( until C++17* )
( until C++17* )
( until C++17* )
( until C++17* ) ( until C++17* ) ( until C++17* ) ( until C++17* )
( until C++20* )
( until C++20* )
( until C++17* ) ( until C++17* )
( until C++17* ) ( until C++17* )

( until C++17* )
( until C++17* ) ( until C++17* ) ( until C++17* ) ( until C++17* )
( until C++20* )
( until C++20* )
std::move_only_function
R operator ( ) ( Args... args ) /*cv*/ /*ref*/ noexcept ( /*noex*/ ) ;
(desde C++23)

Invoca el objetivo invocable almacenado con los parámetros args . Las partes /*cv*/ , /*ref*/ , y /*noex*/ de operator ( ) son idénticas a las del parámetro de plantilla de std::move_only_function .

Equivalente a return std:: invoke_r < R > ( /*cv-ref-cast*/ ( f ) , std:: forward < Args > ( args ) ... ) ; , donde f es un lvalue sin calificadores cv que denota el objeto objetivo de * this , y /*cv-ref-cast*/ ( f ) es equivalente a:

  • f si cv ref está vacío o es & , o
  • std:: as_const ( f ) si cv ref es const o const & , o
  • std :: move ( f ) si cv ref es && , o
  • std :: move ( std:: as_const ( f ) ) si cv ref es const && .

El comportamiento es indefinido si * this está vacío.

Contenidos

Parámetros

args - parámetros para pasar al destino invocable almacenado

Valor de retorno

std:: invoke_r < R > ( /*conversión calificador cv-ref*/ ( f ) , std:: forward < Args > ( args ) ... ) .

Excepciones

Propaga la excepción lanzada por la llamada de función subyacente.

Ejemplo

El siguiente ejemplo muestra cómo std::move_only_function puede pasarse a otras funciones por valor. También muestra cómo std::move_only_function puede almacenar lambdas.

Ejecutar este código 
#include <iostream>
#include <functional>
void call(std::move_only_function<int() const> f)  // can be passed by value
{ 
    std::cout << f() << '\n';
}
int normal_function() 
{
    return 42;
}
int main()
{
    int n = 1;
    auto lambda = [&n](){ return n; };
    std::move_only_function<int() const> f = lambda;
    call(std::move(f));
    n = 2;
    call(lambda); 
    f = normal_function; 
    call(std::move(f));
}

Salida: 

1
2
42

Véase también

invoca el objetivo
(función miembro pública de std::function<R(Args...)> )
llama a la función almacenada
(función miembro pública de std::reference_wrapper<T> )
(C++17) (C++23)
invoca cualquier objeto Callable con los argumentos dados y posibilidad de especificar el tipo de retorno (desde C++23)
(plantilla de función)