Namespaces
Variants

std:: move_only_function

From cppreference.net
C++
Utilities library
Function objects
Function wrappers
(C++11)
move_only_function
(C++23)
(C++26)
(C++26)
(C++11)
(C++11)
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
Défini dans l'en-tête <functional>
template < class ... >
class move_only_function ; // non défini
(1) (depuis C++23)
template < class R, class ... Args >

class move_only_function < R ( Args... ) > ;
template < class R, class ... Args >
class move_only_function < R ( Args... ) noexcept > ;
template < class R, class ... Args >
class move_only_function < R ( Args... ) & > ;
template < class R, class ... Args >
class move_only_function < R ( Args... ) & noexcept > ;
template < class R, class ... Args >
class move_only_function < R ( Args... ) && > ;
template < class R, class ... Args >
class move_only_function < R ( Args... ) && noexcept > ;
template < class R, class ... Args >
class move_only_function < R ( Args... ) const > ;
template < class R, class ... Args >
class move_only_function < R ( Args... ) const noexcept > ;
template < class R, class ... Args >
class move_only_function < R ( Args... ) const & > ;
template < class R, class ... Args >
class move_only_function < R ( Args... ) const & noexcept > ;
template < class R, class ... Args >
class move_only_function < R ( Args... ) const && > ;
template < class R, class ... Args >

class move_only_function < R ( Args... ) const && noexcept > ;
(2) (depuis C++23)

Le modèle de classe std::move_only_function est un wrapper de fonction polymorphe à usage général. Les objets std::move_only_function peuvent stocker et invoquer toute Callable cible constructible (non nécessairement mobile constructible) — fonctions, expressions lambda , expressions de liaison , ou autres objets fonction, ainsi que des pointeurs vers des fonctions membres et des pointeurs vers des objets membres.

L'objet appelable stocké est appelé la cible de std::move_only_function . Si une std::move_only_function ne contient aucune cible, elle est dite vide . Contrairement à std::function , invoquer une vide std::move_only_function entraîne un comportement indéfini.

std::move_only_function prend en charge toutes les combinaisons possibles de qualificateurs cv (à l'exclusion de volatile ), qualificateurs de référence , et spécificateurs noexcept fournis dans son paramètre template. Ces qualificateurs et spécificateurs (le cas échéant) sont ajoutés à son operator() .

std::move_only_function satisfait les exigences de MoveConstructible et MoveAssignable , mais ne satisfait pas CopyConstructible ni CopyAssignable .

Table des matières

Types membres

Type Définition
result_type R

Fonctions membres

construit un nouvel objet std::move_only_function
(fonction membre publique)
détruit un objet std::move_only_function
(fonction membre publique)
remplace ou détruit la cible
(fonction membre publique)
échange les cibles de deux objets std::move_only_function
(fonction membre publique)
vérifie si l'objet std::move_only_function a une cible
(fonction membre publique)
invoque la cible
(fonction membre publique)

Fonctions non membres

(C++23)
spécialise l'algorithme std::swap
(fonction)
(C++23)
compare un std::move_only_function avec nullptr
(fonction)

Notes

Les implémentations peuvent stocker un objet appelable de petite taille dans l'objet std::move_only_function . Une telle optimisation des petits objets est effectivement requise pour les pointeurs de fonction et les spécialisations de std::reference_wrapper , et ne peut être appliquée qu'aux types T pour lesquels std:: is_nothrow_move_constructible_v < T > est true .

Si un std::move_only_function retournant une référence est initialisé à partir d'une fonction ou d'un objet fonction retournant une prvalue (y compris une expression lambda sans type de retour explicite), le programme est mal formé car la liaison de la référence retournée à un objet temporaire est interdite. Voir également les std::function Notes.

Macro de test de fonctionnalité Valeur Std Fonctionnalité
__cpp_lib_move_only_function 202110L (C++23) std::move_only_function

Exemple

Exécuter ce code 
#include <functional>
#include <future>
#include <iostream>
int main()
{
    std::packaged_task<double()> packaged_task([](){ return 3.14159; });
    std::future<double> future = packaged_task.get_future();
    auto lambda = [task = std::move(packaged_task)]() mutable { task(); };
//  std::function<void()> function = std::move(lambda); // Erreur
    std::move_only_function<void()> function = std::move(lambda); // OK
    function();
    std::cout << future.get();
}

Sortie : 

3.14159

Voir aussi

(C++11)
enveloppe copiable de tout objet appelable copiable
(modèle de classe)
(C++26)
enveloppe non propriétaire de tout objet appelable
(modèle de classe)
(C++26)
enveloppe copiable de tout objet appelable copiable qui prend en charge les qualificateurs dans une signature d'appel donnée
(modèle de classe)