static_assert declaration (since C++11)

Führt Überprüfungen zur Compile-Zeit durch.

Syntax

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

Erklärung

Eine static_assert -Deklaration kann im Namensraum- und Block- Scope erscheinen (als eine Blockdeklaration ) und innerhalb eines Klassenkörpers (als eine Memberdeklaration ).

Wenn bool-constexpr wohlgeformt ist und zu true ausgewertet wird, oder im Kontext einer Templatedefinition ausgewertet wird und das Template nicht instanziiert ist, hat diese Deklaration keine Wirkung. Andernfalls wird ein Kompilierzeitfehler ausgegeben, und die benutzerdefinierte 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 eines unevaluated-string entspricht, ist der Text der Nachricht der Text des unevaluated-string .

Hinweise

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

Schlüsselwörter

static_assert

Beispiel

#include <format>
#include <type_traits>
static_assert(03301 == 1729); // seit C++17 ist die Nachrichten-Zeichenkette 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 vor CWG2518/P2593R1
template<class T>
struct bad_type
{
    static_assert(dependent_false<T>, "error on instantiation, workaround");
    static_assert(false, "error on instantiation"); // OK wegen 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
// Noch kein echtes C++ (std::format müsste constexpr sein, um zu funktionieren):
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
}

1: Fehler: Static Assertion fehlgeschlagen: Swap requires copying
2: Fehler: Static Assertion fehlgeschlagen: Data structure requires default-constructible elements
3: Fehler: Static Assertion fehlgeschlagen: Expected 4, got 2

Fehlerberichte

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

Referenzen

Siehe auch