Konzepte-Bibliothek (seit C++20)

 

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)

 

Die Konzepte-Bibliothek stellt Definitionen grundlegender Bibliothekskonzepte bereit, die zur Durchführung von Kompilierungszeitvalidierungen von Template-Argumenten und zur Funktionsauswahl basierend auf den Eigenschaften von Typen verwendet werden können. Diese Konzepte bilden die Grundlage für äquationsorientiertes Schließen in Programmen.

Die meisten Konzepte in der Standardbibliothek legen sowohl syntaktische als auch semantische Anforderungen fest. Es wird gesagt, dass ein Standardkonzept erfüllt ist, wenn seine syntaktischen Anforderungen erfüllt sind, und modelliert ist, wenn es erfüllt ist und seine semantischen Anforderungen (falls vorhanden) ebenfalls erfüllt sind.

Im Allgemeinen können nur die syntaktischen Anforderungen vom Compiler geprüft werden. Wenn die Gültigkeit oder Bedeutung eines Programms davon abhängt, ob eine Sequenz von Template-Argumenten ein Konzept modelliert, und das Konzept erfüllt, aber nicht modelliert ist, oder wenn eine semantische Anforderung an der Verwendungsstelle nicht erfüllt ist, ist das Programm schlecht geformt (ill-formed), keine Diagnose erforderlich.

Gleichheitserhaltung

Ein Ausdruck ist gleichheitserhaltend, wenn er bei gleichen Eingaben gleiche Ausgaben liefert, wobei

• die Eingaben seine Operanden umfassen (nicht notwendigerweise macht dies den Ausdruck semantisch gültig), und
• die Ausgaben sein Ergebnis und alle durch den Ausdruck verursachten Änderungen an den Operanden umfassen, falls vorhanden.

wobei für eine bequemere Formulierung "Operanden" die größten Unterausdrücke bezeichnen, die aus einem id-Ausdruck oder Aufrufen von std::move, std::forward und std::declval bestehen.

Die cv-Qualifikation und die Wertkategorie jedes Operanden werden ermittelt, indem angenommen wird, dass jeder Template-Typ-Parameter in seinem Typ einen cv-unqualifizierten vollständigen Nicht-Array-Objekttyp bezeichnet.

Jeder Ausdruck, der gleichheitserhaltend sein muss, muss außerdem stabil sein, d.h. zwei Auswertungen desselben Ausdrucks mit denselben Eingabeobjekten müssen gleiche Ausgaben liefern, ohne dass eine explizite Änderung dieser Eingabeobjekte dazwischenliegt.

Sofern nicht anders angegeben, muss jeder Ausdruck, der in einem requires Ausdruck der Standardbibliothekskonzepte verwendet wird, gleichheitserhaltend sein, und die Auswertung des Ausdrucks darf nur seine nicht-konstanten Operanden ändern. Konstante Operanden dürfen nicht geändert werden.

In der Standardbibliothek dürfen die folgenden Konzepte nicht gleichheitserhaltende requires Ausdrücke haben:

• output_iterator
• indirectly_writable
• invocable
• weakly_incrementable
• range

Implizite Ausdrucksvariationen

Ein requires Ausdruck, der einen Ausdruck verwendet, der für einen bestimmten konstanten lvalue-Operanden nicht modifizierend ist, impliziert zusätzlich weitere Variationen dieses Ausdrucks, die einen nicht-konstanten lvalue oder einen (möglicherweise konstanten) rvalue für den gegebenen Operanden akzeptieren, es sei denn, eine solche Ausdrucks-Variation wird explizit mit abweichenden Semantiken gefordert.

Diese impliziten Ausdrucksvariationen müssen die gleichen semantischen Anforderungen des deklarierten Ausdrucks erfüllen. Das Ausmaß, in dem eine Implementierung die Syntax der Variationen überprüft, ist nicht spezifiziert.

template<class T>
concept C = requires(T a, T b, const T c, const T d)
{
    c == d;           // expression #1: does not modify the operands
    a = std::move(b); // expression #2: modifies both operands
    a = c;            // expression #3: modifies the left operand `a`
};
 
// Expression #1 implicitly requires additional expression variations that
// meet the requirements for c == d (including non-modification),
// as if the following expressions had been declared as well:
 
// ------ const == const ------- ------ const == non-const ---
//                                         c  ==           b;
//            c == std::move(d);           c  == std::move(b);
// std::move(c) ==           d;  std::move(c) ==           b;
// std::move(c) == std::move(d); std::move(c) == std::move(b);
 
// -- non-const == const ------- -- non-const == non-const ---
//           a  ==           d;            a  ==           b;
//           a  == std::move(d);           a  == std::move(b);
// std::move(a) ==           d;  std::move(a) ==           b;
// std::move(a) == std::move(d); std::move(a) == std::move(b);
 
// Expression #3 implicitly requires additional expression variations that
// meet the requirements for a = c
// (including non-modification of the second operand),
// as if the expressions a = b (non-constant lvalue variation)
// and a = std::move(c) (const rvalue variation) had been declared.
 
// Note: Since expression #2 already requires the non-constant rvalue variation
// (a == std::move(b)) explicitly, expression #3 does not implicitly require it anymore.
 
// The type T meets the explicitly stated syntactic requirements of
// concept C above, but does not meet the additional implicit requirements
// (i.e., T satisfies but does not model C):
// a program requires C<T> is ill-formed (no diagnostic required).
struct T
{
    bool operator==(const T&) const { return true; }
    bool operator==(T&) = delete;
};

Standardbibliothekskonzepte

Definiert im Namespace std
Kernsprachen-Konzepte
Definiert in der Header-Datei <concepts>
same_as (C++20)	gibt an, dass ein Typ identisch mit einem anderen Typ ist (Konzept)
derived_from (C++20)	gibt an, dass ein Typ von einem anderen Typ abgeleitet ist (Konzept)
convertible_to (C++20)	gibt an, dass ein Typ implizit in einen anderen Typ konvertierbar ist (Konzept)
common_reference_with (C++20)	gibt an, dass zwei Typen einen gemeinsamen Referenztyp haben (Konzept)
common_with (C++20)	gibt an, dass zwei Typen einen gemeinsamen Typ haben (Konzept)
integral (C++20)	gibt an, dass ein Typ ein ganzzahliger Typ ist (Konzept)
signed_integral (C++20)	gibt an, dass ein Typ ein vorzeichenbehafteter ganzzahliger Typ ist (Konzept)
unsigned_integral (C++20)	gibt an, dass ein Typ ein vorzeichenloser ganzzahliger Typ ist (Konzept)
floating_point (C++20)	gibt an, dass ein Typ ein Fließkommatyp ist (Konzept)
assignable_from (C++20)	gibt an, dass ein Typ von einem anderen Typ zuweisbar ist (Konzept)
swappableswappable_with (C++20)	gibt an, dass ein Typ vertauscht werden kann oder dass zwei Typen miteinander vertauscht werden können (Konzept)
destructible (C++20)	spezifiziert, dass ein Objekt des Typs zerstört werden kann (Konzept)
constructible_from (C++20)	gibt an, dass eine Variable des Typs aus einer Reihe von Argumenttypen konstruiert oder an sie gebunden werden kann (Konzept)
default_initializable (C++20)	gibt an, dass ein Objekt eines Typs standardkonstruiert werden kann (Konzept)
move_constructible (C++20)	gibt an, dass ein Objekt eines Typs per Move konstruiert werden kann (Konzept)
copy_constructible (C++20)	gibt an, dass ein Objekt eines Typs kopierkonstruiert und per Move konstruiert werden kann (Konzept)
Vergleichskonzepte
Definiert in der Header-Datei <concepts>
boolean-testable  (C++20)	gibt an, dass ein Typ in booleschen Kontexten verwendet werden kann (Exposition-only Konzept*)
equality_comparableequality_comparable_with (C++20)	gibt an, dass der Operator == eine Äquivalenzrelation ist (Konzept)
totally_orderedtotally_ordered_with (C++20)	gibt an, dass die Vergleichsoperatoren des Typs eine Totalordnung ergeben (Konzept)
Definiert in der Header-Datei <compare>
three_way_comparablethree_way_comparable_with (C++20)	gibt an, dass der Operator <=> konsistente Ergebnisse für die gegebenen Typen liefert (Konzept)
Objektkonzepte
Definiert in der Header-Datei <concepts>
movable (C++20)	gibt an, dass ein Objekt eines Typs verschoben und vertauscht werden kann (Konzept)
copyable (C++20)	gibt an, dass ein Objekt eines Typs kopiert, verschoben und vertauscht werden kann (Konzept)
semiregular (C++20)	gibt an, dass ein Objekt eines Typs kopiert, verschoben, vertauscht und standardkonstruiert werden kann (Konzept)
regular (C++20)	gibt an, dass ein Typ regulär ist, d.h. er ist sowohl semiregular als auch equality_comparable (Konzept)
Aufrufbare Konzepte
Definiert in der Header-Datei <concepts>
invocableregular_invocable (C++20)	gibt an, dass ein aufrufbarer Typ mit einem gegebenen Satz von Argumenttypen aufgerufen werden kann (Konzept)
predicate (C++20)	gibt an, dass ein aufrufbarer Typ ein boolesches Prädikat ist (Konzept)
relation (C++20)	gibt an, dass ein aufrufbarer Typ eine binäre Relation ist (Konzept)
equivalence_relation (C++20)	gibt an, dass eine Relation eine Äquivalenzrelation darstellt (Konzept)
strict_weak_order (C++20)	gibt an, dass eine Relation eine strikt schwache Ordnung darstellt (Konzept)

Zusätzliche Konzepte finden Sie in der Iteratoren-Bibliothek, der Algorithmen-Bibliothek und der Ranges-Bibliothek.

Siehe auch

• Benannte Anforderungen