static_assert Deklaration (seit C++11)

 

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

 

C++ Sprache

Allgemeine Themen
Präprozessor Kommentare	Schlüsselwörter Escape-Sequenzen
Kontrollfluss
Bedingte Ausführungsaussagen
if	switch
Iterationsanweisungen (Schleifen)
for Bereichs-for (C++11)	while do-while
Sprunganweisungen
continue - break	goto - return
Funktionen
Funktionsdeklaration
Lambda-Funktionsausdruck
inline-Spezifizierer
Dynamische Ausnahmespezifikationen (bis C++17*)
noexcept-Spezifizierer (C++11)
Ausnahmen
throw-Ausdruck try-Block	catch-Handler
Namensräume
Namensdeklaration	Namensaliase
Typen
Fundamentale Typen Aufzählungstypen Funktionstypen	Klassen-/Strukturtypen Union-Typen
Spezifizierer
const/volatile decltype (C++11) auto (C++11)	constexpr (C++11) consteval (C++20) constinit (C++20)
Speicherdauer-Spezifizierer
Initialisierung
Standardinitialisierung Wertinitialisierung Nullinitialisierung Kopierinitialisierung Direkte Initialisierung	Aggregatinitialisierung Listeninitialisierung (C++11)   Konstante Initialisierung Referenzinitialisierung

Ausdrücke
Wertkategorien Reihenfolge der Auswertung	Operatoren Operatorrangfolge
Alternative Darstellungen
Literale
Boolesch - Ganzzahl - Gleitkommazahl
Zeichen - String - nullptr (C++11)
Benutzerdefinierte (C++11)
Dienstprogramme
Attribute (C++11)
Typen
typedef-Deklaration
Typalias-Deklaration (C++11)
Umwandlungen
Implizite Konvertierungen static_cast const_cast	Explizite Konvertierungen dynamic_cast reinterpret_cast
Speicherzuweisung
new-Ausdruck	delete-Ausdruck
Klassen
Klassendeklaration Konstruktoren this-Zeiger	Zugriffsspezifizierer friend-Spezifizierer
Klassenspezifische Funktionseigenschaften
Virtuelle Funktion override-Spezifizierer (C++11)   final-Spezifizierer (C++11)	explicit (C++11) static
Spezielle Member-Funktionen
Standardkonstruktor Kopierkonstruktor Move-Konstruktor (C++11)	Kopierzuweisung Move-Zuweisung (C++11) Destruktor
Templates
Klassenschablone Funktionsschablone	Schablonenspezialisierung Parameter-Pakete (C++11)
Sonstiges
Inline-Assembler	Geschichte von C++

 

Deklarationen

Übersicht Deklarationssyntax decl-specifier-seq Deklarator Konfligierende Deklarationen Spezifizierer typedef inline virtual Funktionsspezifizierer explicit Funktionsspezifizierer friend constexpr (C++11) consteval (C++20) constinit (C++20) Speicherklassen-Spezifizierer Übersetzungseinheits-lokal (C++20) class/struct union enum decltype (C++11) auto (C++11) alignas (C++11) constvolatile Pack-Indizierungs-Spezifizierer (C++26)     Elaborierter Typ-Spezifizierer Attribute (C++11)

Deklaratoren Referenz Zeiger Array Blockdeklarationen Einfache Deklaration   →Strukturierte Bindungsdeklaration (C++17) Alias-Deklaration (C++11) Namespace-Alias-Definition using Deklaration using-Direktive static_assert Deklaration (C++11) asm-Deklaration Opaque Enum-Deklaration (C++11) Andere Deklarationen Namespace-Definition Funktionsdeklaration Klassentemplatedeklaration Funktionstemplatedeklaration Explizite Template-Instanziierung (C++11) Explizite Templatespezialisierung Linkage-Spezifikation Attributdeklaration (seit C++11) Leere Deklaration

 

Führt Assertionsprüfungen zur Kompilierzeit durch.

Syntax

static_assert( bool-constexpr , unevaluated-string )	(1)
static_assert( bool-constexpr )	(2)	(seit C++17)
static_assert( bool-constexpr , constant-expression )	(3)	(seit C++26)

Deklariert eine statische Assertion. Wenn die Assertion fehlschlägt, ist das Programm fehlerhaft und es kann eine diagnostische Fehlermeldung generiert werden.

1) Eine statische Assertion mit fester Fehlermeldung.

2) Eine statische Assertion ohne Fehlermeldung.

3) Eine statische Assertion mit einer vom Benutzer generierten Fehlermeldung.

Diese Syntax kann nur übereinstimmen, wenn die Syntax (1) nicht übereinstimmt.

Erklärung

bool-constexpr	-	ein kontextuell konvertierter konstanter Ausdruck vom Typ bool. Eingebaute Konvertierungen sind nicht erlaubt, mit Ausnahme von nicht-verengenden ganzzahligen Konvertierungen zu bool. (bis C++23) ein Ausdruck, der kontextuell zu bool konvertiert wird, wobei die Konvertierung ein konstanter Ausdruck ist. (seit C++23)
unevaluated-string	-	ein nicht ausgewertetes String-Literal, das als Fehlermeldung erscheint.
konstanter Ausdruck	-	ein konstanter Ausdruck msg, der alle folgenden Bedingungen erfüllt msg.size() ist implizit konvertierbar zu std::size_t. msg.data() ist implizit konvertierbar zu const char*.

Eine static_assert Deklaration kann im Namespace- und Block-Geltungsbereich (als Block-Deklaration) und innerhalb eines Klassenkörpers (als Mitgliedsdeklaration) erscheinen.

Wenn bool-constexpr wohlgeformt ist und zu true ausgewertet wird, oder im Kontext einer Template-Definition ausgewertet wird und das Template nicht instanziiert wird, hat diese Deklaration keine Auswirkung. Andernfalls wird ein Kompilierungsfehler ausgegeben und die vom Benutzer bereitgestellte Nachricht, falls vorhanden, wird in die Diagnosemeldung aufgenommen.

Der Text der vom Benutzer bereitgestellten Nachricht wird wie folgt bestimmt:

• Wenn die Nachricht den syntaktischen Anforderungen von unevaluated-string entspricht, ist der Text der Nachricht der Text des unevaluated-string.

Andernfalls, unter Berücksichtigung der folgenden Werte: Sei msg der Wert von constant-expression. Sei len der Wert von msg.size(), welcher ein konvertierter konstanter Ausdruck vom Typ std::size_t sein muss. Sei ptr der Ausdruck msg.data(), implizit konvertiert zu const char*. ptr muss ein Kern-konstanter Ausdruck sein. Der Text der Nachricht wird aus der Sequenz von len Code-Einheiten gebildet, beginnend bei ptr, der einfachen Literal-Kodierung. Für jede Ganzzahl i in [​0​, len) muss ptr[i] ein ganzzahliger konstanter Ausdruck sein.

(seit C++26)

Hinweise

Der Standard schreibt nicht vor, dass ein Compiler den exakten Text der Fehlermeldung ausgibt, obwohl Compiler dies im Allgemeinen so weit wie möglich tun.

Da die Fehlermeldung ein String-Literal sein muss, kann sie keine dynamischen Informationen oder sogar einen konstanten Ausdruck enthalten, der selbst kein String-Literal ist. Insbesondere kann sie nicht den Namen des Template-Typarguments enthalten.

(bis C++26)

Feature-Testmakro	Wert	Std	Feature
__cpp_static_assert	200410L	(C++11)	static_assert (Syntax (1))
	201411L	(C++17)	static_assert mit einem Argument (Syntax (2))
	202306L	(C++26)	vom Benutzer generierte Fehlermeldungen (Syntax (3))

Schlüsselwörter

static_assert

Beispiel

Führen Sie diesen Code aus

#include <format>
#include <type_traits>
 
static_assert(03301 == 1729); // since C++17 the message string is optional
 
template<class T>
void swap(T& a, T& b) noexcept
{
    static_assert(std::is_copy_constructible_v<T>,
                  "Swap requires copying");
    static_assert(std::is_nothrow_copy_constructible_v<T> &&
                  std::is_nothrow_copy_assignable_v<T>,
                  "Swap requires nothrow copy/assign");
    auto c = b;
    b = a;
    a = c;
}
 
template<class T>
struct data_structure
{
    static_assert(std::is_default_constructible_v<T>,
                  "Data structure requires default-constructible elements");
};
 
template<class>
constexpr bool dependent_false = false; // workaround before CWG2518/P2593R1
 
template<class T>
struct bad_type
{
    static_assert(dependent_false<T>, "error on instantiation, workaround");
    static_assert(false, "error on instantiation"); // OK because of CWG2518/P2593R1
};
 
struct no_copy
{
    no_copy(const no_copy&) = delete;
    no_copy() = default;
};
 
struct no_default
{
    no_default() = delete;
};
 
#if __cpp_static_assert >= 202306L
// Not real C++ yet (std::format should be constexpr to work):
static_assert(sizeof(int) == 4, std::format("Expected 4, got {}", sizeof(int)));
#endif
 
int main()
{
    int a, b;
    swap(a, b);
 
    no_copy nc_a, nc_b;
    swap(nc_a, nc_b); // 1
 
    [[maybe_unused]] data_structure<int> ds_ok;
    [[maybe_unused]] data_structure<no_default> ds_error; // 2
}

Mögliche Ausgabe

1: error: static assertion failed: Swap requires copying
2: error: static assertion failed: Data structure requires default-constructible elements
3: error: static assertion failed: Expected 4, got 2

Defect reports

Die folgenden Verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR	angewendet auf	Verhalten wie veröffentlicht	Korrigiertes Verhalten
CWG 2039	C++11	nur der Ausdruck vor der Konvertierung muss konstant sein	die Konvertierung muss ebenfalls in einem konstanten Ausdruck gültig sein
CWG 2518 (P2593R1)	C++11	nicht instanziiertes static_assert(false, ""); war fehlerhaft	wurde wohlgeformt gemacht

Referenzen

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

• 9.1 Preamble [dcl.pre] (p: 10)

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

• 9.1 Preamble [dcl.pre] (p: 6)

• C++17 Standard (ISO/IEC 14882:2017)

• 10 Declarations [dcl.dcl] (p: 6)

• C++14 Standard (ISO/IEC 14882:2014)

• 7 Declarations [dcl.dcl] (p: 4)

• C++11 Standard (ISO/IEC 14882:2011)

• 7 Declarations [dcl.dcl] (p: 4)

Siehe auch

#error	zeigt die angegebene Fehlermeldung an und macht das Programm fehlerhaft (Präprozessor-Direktive)
assert	bricht das Programm ab, wenn die vom Benutzer angegebene Bedingung nicht true ist. Kann für Release-Builds deaktiviert werden. (Funktionsmakro)
contract_assert-Anweisung (C++26)	verifiziert eine interne Bedingung während der Ausführung
enable_if (C++11)	entfernt bedingt eine Funktionsüberladung oder Template-Spezialisierung aus der Überladungsauflösung (Klassenvorlage)
Typ-Traits (C++11)	definieren Template-basierte Schnittstellen zur Kompilierzeit, um die Eigenschaften von Typen abzufragen.
C-Dokumentation für Statische Assertion