std::assignable_from

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Konzeptbibliothek

Kernsprachen-Konzepte same_as (C++20) derived_from (C++20) convertible_to (C++20) common_reference_with (C++20) common_with (C++20) integral (C++20) signed_integral (C++20) unsigned_integral (C++20) floating_point (C++20) swappableswappable_with (C++20)(C++20) destructible (C++20) constructible_from (C++20) default_initializable (C++20)   move_constructible (C++20) copy_constructible (C++20) assignable_from (C++20)

Vergleichskonzepte equality_comparableequality_comparable_with (C++20)(C++20) totally_orderedtotally_ordered_with (C++20)(C++20) Objektkonzepte movable (C++20) copyable (C++20) semiregular (C++20) regular (C++20) Aufrufbare Konzepte invocableregular_invocable (C++20)(C++20) predicate (C++20) relation (C++20) equivalence_relation (C++20) strict_weak_order (C++20)

Exposition-only Konzepte boolean-testable  (C++20)

 

Definiert in der Header-Datei <concepts>
template< class LHS, class RHS > concept assignable_from =     std::is_lvalue_reference_v<LHS> &&     std::common_reference_with<         const std::remove_reference_t<LHS>&,         const std::remove_reference_t<RHS>&> &&     requires(LHS lhs, RHS&& rhs) {         { lhs = std::forward<RHS>(rhs) } -> std::same_as<LHS>;     };		(seit C++20)

Das Konzept assignable_from<LHS, RHS> spezifiziert, dass ein Ausdruck des von RHS spezifizierten Typs und der Wertkategorie an einen lvalue-Ausdruck zugewiesen werden kann, dessen Typ von LHS spezifiziert wird.

Semantische Anforderungen

Gegeben

• lhs, ein lvalue, 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 modelliert, wenn

• std::addressof(lhs = rhs) == std::addressof(lcopy) (d. h. der Zuweisungsausdruck ergibt einen lvalue, der auf den linken Operanden verweist);
• Nach der Auswertung von lhs = rhs
  • ist lhs gleich rcopy, es sei denn, rhs ist ein nicht-const xvalue, das auf lcopy verweist (d. h. die Zuweisung ist eine Selbst-Move-Zuweisung).
  • wenn rhs ein glvalue ist
    • Wenn es sich um einen nicht-const xvalue handelt, befindet sich das Objekt, auf das er verweist, in einem gültigen, aber nicht spezifizierten Zustand;
    • Andernfalls wird das Objekt, auf das er verweist, nicht geändert;

Gleichheitserhaltung

Ausdrücke, die in requires-Ausdrücken der Standardbibliothekskonzepte deklariert sind, müssen gleichheitserhaltend sein (sofern nicht anders angegeben).

Hinweise

Zuweisung muss keine totale Funktion sein. Insbesondere, wenn die Zuweisung an ein Objekt x dazu führen kann, dass ein anderes Objekt y geändert wird, dann ist x = y wahrscheinlich nicht im Definitionsbereich von =. Dies geschieht typischerweise, 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

Führen Sie diesen Code aus

#include <atomic>
#include <concepts>
#include <string>
 
int main()
{
    // Normal basic usage, checks lvalue reference assignment
    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>);
 
    // Fundamental types don't support assignment to an rvalue
    static_assert(!std::is_assignable_v<int, int>);
    static_assert(!std::assignable_from<int, int>);
 
    // std::assignable_from doesn't accept all valid assignment expressions:
 
    // rvalue reference assignment
    static_assert(std::is_assignable_v<std::string&&, std::string>);
    static_assert(!std::assignable_from<std::string&&, std::string>);
 
    // rvalue assignment
    static_assert(std::is_assignable_v<std::string, std::string>);
    static_assert(!std::assignable_from<std::string, std::string>);
 
    // std::atomic::operator= returns by value
    static_assert(std::is_assignable_v<std::atomic<int>&, int>);
    static_assert(!std::assignable_from<std::atomic<int>&, int>);
}

Referenzen

• C++23 Standard (ISO/IEC 14882:2024)

• 18.4.8 Konzept assignable_from [concept.assignable]

• C++20 Standard (ISO/IEC 14882:2020)

• 18.4.8 Konzept assignable_from [concept.assignable]

Siehe auch

is_assignableis_trivially_assignableis_nothrow_assignable (C++11)(C++11)(C++11)

prüft, ob ein Typ einen Zuweisungsoperator für ein bestimmtes Argument hat (Klassenvorlage)