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
(Anmerkung: Da der bereitgestellte HTML-Code keinen übersetzbaren Text enthält, bleibt die Ausgabe identisch mit der Eingabe. Die Tabellenzellen sind leer und enthalten keine Textinhalte zur Übersetzung.)
Definiert im Header <functional>
template < class ... >
class move_only_function ; // nicht definiert
(1) (seit 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) (seit C++23)

Die Klassenvorlage std::move_only_function ist ein allgemeiner polymorpher Funktionswrapper. std::move_only_function -Objekte können jeden konstruierbaren (nicht notwendigerweise beweglich konstruierbaren) Callable Target speichern und aufrufen — Funktionen, Lambda-Ausdrücke , Bind-Ausdrücke oder andere Funktionsobjekte, sowie Zeiger auf Elementfunktionen und Zeiger auf Elementobjekte.

Das gespeicherte aufrufbare Objekt wird als Target von std::move_only_function bezeichnet. Wenn eine std::move_only_function kein Target enthält, wird sie als leer bezeichnet. Im Gegensatz zu std::function führt der Aufruf einer leeren std::move_only_function zu undefiniertem Verhalten.

std::move_only_function unterstützt jede mögliche Kombination von cv-Qualifizierern (ohne volatile ), Ref-Qualifizierern und noexcept-Spezifizierern , die in seinem Template-Parameter angegeben sind. Diese Qualifizierer und Spezifizierer (falls vorhanden) werden zu seinem operator() hinzugefügt.

std::move_only_function erfüllt die Anforderungen von MoveConstructible und MoveAssignable , erfüllt jedoch nicht CopyConstructible oder CopyAssignable .

Inhaltsverzeichnis

Mitgliedertypen

Typ Definition
result_type R

Memberfunktionen

konstruiert ein neues std::move_only_function Objekt
(öffentliche Elementfunktion)
zerstört ein std::move_only_function Objekt
(öffentliche Elementfunktion)
ersetzt oder zerstört das Zielobjekt
(öffentliche Elementfunktion)
tauscht die Ziele zweier std::move_only_function Objekte
(öffentliche Elementfunktion)
prüft ob die std::move_only_function ein Zielobjekt besitzt
(öffentliche Elementfunktion)
ruft das Zielobjekt auf
(öffentliche Elementfunktion)

Nicht-Member-Funktionen

(C++23)
spezialisiert den std::swap Algorithmus
(Funktion)
(C++23)
vergleicht ein std::move_only_function mit nullptr
(Funktion)

Hinweise

Implementierungen können ein aufrufbares Objekt kleiner Größe innerhalb des std::move_only_function Objekts speichern. Eine solche Small-Object-Optimierung ist effektiv für Funktionszeiger und std::reference_wrapper Spezialisierungen erforderlich und kann nur auf Typen T angewendet werden, für die std:: is_nothrow_move_constructible_v < T > true ist.

Wenn ein std::move_only_function , das eine Referenz zurückgibt, von einer Funktion oder einem Funktionsobjekt initialisiert wird, das einen Prvalue zurückgibt (einschließlich eines Lambda-Ausdrucks ohne nachgestellten Rückgabetyp), ist das Programm fehlerhaft, da das Binden der zurückgegebenen Referenz an ein temporäres Objekt verboten ist. Siehe auch std::function Notes.

Feature-Test Makro Wert Std Feature
__cpp_lib_move_only_function 202110L (C++23) std::move_only_function

Beispiel

Diesen Code ausführen 
#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); // Fehler
    std::move_only_function<void()> function = std::move(lambda); // OK
    function();
    std::cout << future.get();
}

Ausgabe: 

3.14159

Siehe auch

(C++11)
kopierbarer Wrapper für jedes kopierkonstruierbare aufrufbare Objekt
(Klassentemplate)
(C++26)
nicht-besitzender Wrapper für jedes aufrufbare Objekt
(Klassentemplate)
(C++26)
kopierbarer Wrapper für jedes kopierkonstruierbare aufrufbare Objekt, das Qualifier in einer gegebenen Aufrufsignatur unterstützt
(Klassentemplate)