std:: assignable_from

Das Konzept assignable_from<LHS, RHS> spezifiziert, dass ein Ausdruck des durch RHS spezifizierten Typs und Wertkategorie einem Lvalue-Ausdruck zugewiesen werden kann, dessen Typ durch LHS spezifiziert ist.

Semantische Anforderungen

Gegeben

• lhs , ein L-Wert, der auf ein Objekt lcopy verweist, sodass decltype ( ( lhs ) ) LHS ist,
• rhs , ein Ausdruck, sodass decltype ( ( rhs ) ) RHS ist,
• rcopy , ein separates Objekt, das gleich rhs ist,

assignable_from<LHS, RHS> wird nur dann modelliert, wenn

• std:: addressof ( lhs = rhs ) == std:: addressof ( lcopy ) (d.h. der Zuweisungsausdruck ergibt einen Lvalue, der auf den linken Operanden verweist);
• Nach Auswertung von lhs = rhs :
  • lhs ist gleich rcopy , es sei denn rhs ist ein non-const Xvalue, der auf lcopy verweist (d.h. die Zuweisung ist eine Selbst-Zuweisung durch Move);
  • wenn rhs ein Glvalue ist:
    • Falls es ein non-const Xvalue ist, befindet sich das Objekt, auf das es verweist, in einem gültigen aber unspezifizierten Zustand;
    • Andernfalls ist das referenzierte Objekt nicht modifiziert;

Gleichheitserhaltung

Ausdrücke, die in requires expressions der Standardbibliothek-Konzepte deklariert werden, müssen equality-preserving sein (sofern nicht anders angegeben).

Hinweise

Zuweisung muss keine totale Funktion sein. Insbesondere, wenn die Zuweisung zu einem Objekt x die Änderung eines anderen Objekts y verursachen kann, dann liegt x = y wahrscheinlich nicht im Definitionsbereich von = . Dies tritt typischerweise auf, wenn der rechte Operand direkt oder indirekt vom linken Operanden besessen wird (z.B. mit Smart Pointern zu Knoten in einer knotenbasierten Datenstruktur, oder mit etwas wie std:: vector < std:: any > ).

Beispiel

#include <atomic>
#include <concepts>
#include <string>
int main()
{
    // Normale grundlegende Verwendung, prüft Zuweisung von Lvalue-Referenzen
    static_assert(std::is_assignable_v<int&, int>);
    static_assert(std::assignable_from<int&, int>);
    static_assert(std::is_assignable_v<std::string&, std::string>);
    static_assert(std::assignable_from<std::string&, std::string>);
    // Grundlegende Typen unterstützen keine Zuweisung an einen Rvalue
    static_assert(!std::is_assignable_v<int, int>);
    static_assert(!std::assignable_from<int, int>);
    // std::assignable_from akzeptiert nicht alle gültigen Zuweisungsausdrücke:
    // Zuweisung von Rvalue-Referenzen
    static_assert(std::is_assignable_v<std::string&&, std::string>);
    static_assert(!std::assignable_from<std::string&&, std::string>);
    // Rvalue-Zuweisung
    static_assert(std::is_assignable_v<std::string, std::string>);
    static_assert(!std::assignable_from<std::string, std::string>);
    // std::atomic::operator= gibt einen Wert zurück
    static_assert(std::is_assignable_v<std::atomic<int>&, int>);
    static_assert(!std::assignable_from<std::atomic<int>&, int>);
}

Referenzen

Siehe auch