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*/ ) ;
(depuis C++23)

Appelle la cible appelable stockée avec les paramètres args . Les parties /*cv*/ , /*ref*/ , et /*noex*/ de operator ( ) sont identiques à celles du paramètre template de std::move_only_function .

Équivalent à return std:: invoke_r < R > ( /*cv-ref-cast*/ ( f ) , std:: forward < Args > ( args ) ... ) ; , où f est une lvalue non qualifiée cv qui désigne l'objet cible de * this , et /*cv-ref-cast*/ ( f ) est équivalent à :

  • f si cv ref est vide ou contient & , ou
  • std:: as_const ( f ) si cv ref contient const ou const & , ou
  • std :: move ( f ) si cv ref est && , ou
  • std :: move ( std:: as_const ( f ) ) si cv ref est const && .

Le comportement n'est pas défini si * this est vide.

Table des matières

Paramètres

args - paramètres à passer à la cible appelable stockée

Valeur de retour

std:: invoke_r < R > ( /*conversion qualifiée-référence*/ ( f ) , std:: forward < Args > ( args ) ... ) .

Exceptions

Propage l'exception levée par l'appel de fonction sous-jacent.

Exemple

L'exemple suivant montre comment std::move_only_function peut être passé à d'autres fonctions par valeur. Il montre également comment std::move_only_function peut stocker des lambdas.

Exécuter ce code 
#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));
}

Sortie : 

1
2
42

Voir aussi

invoque la cible
(fonction membre publique de std::function<R(Args...)> )
appelle la fonction stockée
(fonction membre publique de std::reference_wrapper<T> )
(C++17) (C++23)
invoque tout objet Callable avec les arguments donnés et possibilité de spécifier le type de retour (depuis C++23)
(modèle de fonction)