Constant expressions

Definiert einen Ausdruck , der zur Kompilierzeit ausgewertet werden kann.

Solche Ausdrücke können als konstante Template-Argumente, Array-Größen und in anderen Kontexten verwendet werden, die konstante Ausdrücke erfordern, z.B.

int n = 1;
std::array<int, n> a1;  // Fehler: „n“ ist kein konstanter Ausdruck
const int cn = 2;
std::array<int, cn> a2; // OK: „cn“ ist ein konstanter Ausdruck

Definition

Bei der Bestimmung, ob ein Ausdruck ein konstanter Ausdruck ist, wird angenommen, dass Copy Elision nicht durchgeführt wird.

Die Definition von konstanten Ausdrücken in C++98 befindet sich vollständig innerhalb der Ausklappbox. Die folgende Beschreibung gilt für C++11 und spätere C++-Versionen.

Literaltyp

Die folgenden Typen werden zusammenfassend als literal types bezeichnet:

• möglicherweise cv-qualifiziertes void
• Skalartyp
• Referenztyp
• ein Array von Literaltyp
• möglicherweise cv-qualifizierter Klassentyp, der alle folgenden Bedingungen erfüllt:

• Es besitzt einen trivialen Destruktor (bis C++20) constexpr Destruktor (seit C++20) .
• Alle seine nicht-statischen nicht-varianten Datenelemente und Basisklassen sind von nicht-flüchtigen Literaltypen.
• Es ist einer der folgenden Typen:

• ein Aggregat -Union-Typ, der eine der folgenden Bedingungen erfüllt:

• Er hat kein Varianten-Mitglied .
• Er hat mindestens ein Varianten-Mitglied von nicht-flüchtigem Literaltyp.

• ein Nicht-Union-Aggregat-Typ, bei dem jedes seiner anonymen Union -Mitglieder eine der folgenden Bedingungen erfüllt:

• Es hat kein Varianten-Mitglied.
• Es hat mindestens ein Varianten-Mitglied von nicht-flüchtigem Literaltyp.

• ein Typ mit mindestens einem constexpr -Konstruktor (Template), der kein Kopier- oder Verschiebungskonstruktor ist

Nur Objekte von Literaltypen können innerhalb eines konstanten Ausdrucks erstellt werden.

Kernkonstanter Ausdruck

Ein Kernkonstanter Ausdruck ist jeder Ausdruck, dessen Auswertung nicht eine der folgenden Sprachkonstrukte auswerten würde:

1. a function call expression that calls a function (or a constructor) that is not declared constexpr

   constexpr int n = std::numeric_limits<int>::max(); // OK: max() ist constexpr
   constexpr int m = std::time(nullptr); // Fehler: std::time() ist nicht constexpr

2. a function call to a constexpr function which is declared, but not defined
3. a function call to a constexpr function/constructor template instantiation where the instantiation fails to satisfy constexpr-Funktion/-Konstruktor requirements.
4. a function call to a constexpr virtual function, invoked on an object whose dynamic type is constexpr-unknown
5. an expression that would exceed the implementation-defined limits
6. an expression whose evaluation leads to any form of core language undefined oder fehlerhaft (seit C++26) behavior, except for any potential undefined behavior introduced by Standardattribute .

   constexpr double d1 = 2.0 / 1.0; // OK
   constexpr double d2 = 2.0 / 0.0; // Fehler: nicht definiert
   constexpr int n = std::numeric_limits<int>::max() + 1; // Fehler: Überlauf
   int x, y, z[30];
   constexpr auto e1 = &y - &x;        // Fehler: undefiniert
   constexpr auto e2 = &z[20] - &z[3]; // OK
   constexpr std::bitset<2> a; 
   constexpr bool b = a[2]; // UB, aber unbestimmt ob erkannt

7. (bis C++17) a Lambda-Ausdruck
8. an lvalue-to-rvalue implizite Konvertierung unless applied to...
   1. ein glvalue vom Typ (möglicherweise cv-qualifiziert) std::nullptr_t
   2. ein nicht-flüchtiger Literal-Typ-glvalue, der ein Objekt bezeichnet, das in konstanten Ausdrücken verwendbar ist

      int main()
      {
          const std::size_t tabsize = 50;
          int tab[tabsize]; // OK: tabsize ist ein konstanter Ausdruck
                            // weil tabsize in konstanten Ausdrücken verwendbar ist
                            // da es const-qualifizierten integralen Typ hat und
                            // sein Initialisierer ein konstanter Initialisierer ist
          std::size_t n = 50;
          const std::size_t sz = n;
          int tab2[sz]; // Fehler: sz ist kein konstanter Ausdruck
                        // weil sz nicht in konstanten Ausdrücken verwendbar ist
                        // da sein Initialisierer kein konstanter Initialisierer war
      }

   3. ein nicht-flüchtiger Literal-Typ-glvalue, der sich auf ein nicht-flüchtiges Objekt bezieht, dessen Lebensdauer innerhalb der Auswertung dieses Ausdrucks begann
9. an lvalue-to-rvalue implizite Konvertierung or modification applied to a non-active member of a Union or its subobject (even if it shares a common initial sequence with the active member)
10. an lvalue-to-rvalue implicit conversion on an object dessen Wert unbestimmt ist
11. an invocation of implicit copy/move constructor/assignment for a union whose active member is mutable (if any), with lifetime beginning outside the evaluation of this expression
12. (bis C++20) an assignment expression that would change the active member of a union
13. conversion from Zeiger auf void to a pointer-to-object type T* es sei denn, der Zeiger hält einen Nullzeigerwert oder zeigt auf ein Objekt, dessen Typ ähnlich zu T ist (seit C++26)
14. dynamic_cast dessen Operand ein Glvalue ist, der sich auf ein Objekt bezieht, dessen dynamischer Typ constexpr-unbekannt ist (since C++20)
15. reinterpret_cast
16. (bis C++20) pseudo-destructor call
17. (bis C++14) an increment or a decrement operator
18. (seit C++14) modification of an object, unless the object has non-volatile literal type and its lifetime began within the evaluation of the expression

    constexpr int incr(int& n)
    {
        return ++n;
    }
    constexpr int g(int k)
    {
        constexpr int x = incr(k); // Fehler: incr(k) ist kein Kern-Konstantenausdruck
                                   // weil die Lebensdauer von k
                                   // außerhalb des Ausdrucks incr(k) begann
        return x;
    }
    constexpr int h(int k)
    {
        int x = incr(k); // OK: x muss nicht mit einem Kern-Konstantenausdruck
                         // initialisiert werden
        return x;
    }
    constexpr int y = h(1); // OK: initialisiert y mit dem Wert 2
                            // h(1) ist ein Kern-Konstantenausdruck, weil
                            // die Lebensdauer von k innerhalb des Ausdrucks h(1) beginnt

19. (seit C++20) a destructor call or pseudo destructor call for an object whose lifetime did not begin within the evaluation of this expression
20. a typeid expression applied to a glvalue of polymorphic type und dieser Glvalue verweist auf ein Objekt, dessen dynamischer Typ constexpr-unbekannt ist (seit C++20)
21. a new Ausdruck , es sei denn, eine der folgenden Bedingungen ist erfüllt: (seit C++20)

    Die ausgewählte Allokationsfunktion ist eine ersetzbare globale Allokationsfunktion und der allokierte Speicher wird innerhalb der Auswertung dieses Ausdrucks freigegeben.

    (since C++20)

    Die ausgewählte Allokationsfunktion ist eine nicht-allokierende Form mit einem allokierten Typ T , und das Platzierungsargument erfüllt alle folgenden Bedingungen: Es zeigt auf: ein Objekt, dessen Typ ähnlich zu T ist, falls T kein Array-Typ ist, oder das erste Element eines Objekts eines Typs ähnlich zu T , falls T ein Array-Typ ist. Es zeigt auf Speicher, dessen Lebensdauer innerhalb der Auswertung dieses Ausdrucks begann.

    (since C++26)

22. a delete Ausdruck , es sei denn, es gibt einen Speicherbereich frei, der innerhalb der Auswertung dieses Ausdrucks alloziert wurde (since C++20)
23. (seit C++20) Coroutines: an Await-Ausdruck or a Yield-Ausdruck
24. (seit C++20) a Drei-Wege-Vergleich when the result is unspecified
25. an equality or relational operator whose result is unspecified
26. (bis C++14) an assignment or a compound assignment operator
27. (bis C++26) ein throw-Ausdruck
28. (seit C++26) die Konstruktion eines Ausnahmeobjekts, es sei denn, das Ausnahmeobjekt und alle seine impliziten Kopien, die durch Aufrufe von std::current_exception oder std::rethrow_exception erstellt wurden, werden innerhalb der Auswertung dieses Ausdrucks zerstört

    constexpr void check(int i)
    {
        if (i < 0)
            throw i;
    }
    constexpr bool is_ok(int i)
    {
        try {
            check(i);
        } catch (...) {
            return false;
        }
        return true;
    }
    constexpr bool always_throw()
    {
        throw 12;
        return true;
    }
    static_assert(is_ok(5)); // OK
    static_assert(!is_ok(-1)); // OK seit C++26
    static_assert(always_throw()); // Fehler: ungefangene Ausnahme

29. eine asm-Deklaration
30. ein Aufruf des va_arg Makros
31. eine goto Anweisung
32. ein dynamic_cast oder typeid Ausdruck oder new Ausdruck (seit C++26) der eine Ausnahme werfen würde wo keine Definition des Ausnahmetyps erreichbar ist (seit C++26)
33. innerhalb eines Lambda-Ausdrucks, eine Referenz auf this oder auf eine Variable, die außerhalb dieses Lambdas definiert ist, wenn diese Referenz eine ODR-Nutzung wäre

    void g()
    {
        const int n = 0;
        constexpr int j = *&n; // OK: außerhalb eines Lambda-Ausdrucks
        [=]
        {
            constexpr int i = n;   // OK: 'n' wird hier nicht ODR-genutzt und nicht erfasst.
            constexpr int j = *&n; // Ungültig: '&n' wäre eine ODR-Nutzung von 'n'.
        };
    }

    Hinweis: Wenn die ODR-Nutzung in einem Funktionsaufruf an einen Closure stattfindet, bezieht sie sich nicht auf this oder auf eine umschließende Variable, da sie auf ein Datenmitglied des Closures zugreift // OK: 'v' & 'm' werden ODR-genutzt, kommen aber nicht in einem konstanten Ausdruck // innerhalb des verschachtelten Lambdas vor auto monad = [](auto v){ return [=]{ return v; }; }; auto bind = [](auto m){ return [=](auto fvm){ return fvm(m()); }; }; // OK, Erfassungen von automatischen Objekten, die während der konstanten Ausdrucksauswertung erstellt wurden, zu haben. static_assert(bind(monad(2))(monad)() == monad(2)());

    (seit C++17)

Zusätzliche Anforderungen

Selbst wenn ein Ausdruck E nichts der oben genannten Dinge auswertet, ist implementierungsdefiniert, ob E ein Kernkonstanter Ausdruck ist, wenn die Auswertung von E zu Laufzeit-undefiniertem Verhalten führen würde.

Selbst wenn ein Ausdruck E nichts der oben genannten Dinge auswertet, ist es unspezifiziert, ob E ein Core Constant Expression ist, wenn die Auswertung von E eines der folgenden Dinge auswerten würde:

• Eine Operation mit undefiniertem Verhalten in der Standardbibliothek .
• Ein Aufruf des va_start Makros.

Für die Bestimmung, ob ein Ausdruck ein Kernkonstantenausdruck ist, wird die Auswertung des Rumpfes einer Elementfunktion von std:: allocator < T > ignoriert, falls T ein Literaltyp ist.

Zum Zweck der Bestimmung, ob ein Ausdruck ein Kernkonstanter Ausdruck ist, wird die Auswertung eines Aufrufs eines trivialen Kopier-/Verschiebekonstruktors oder einer Kopier-/Verschiebezuweisung einer Union als Kopieren/Verschieben des aktiven Members der Union betrachtet, falls vorhanden.

Während der Auswertung des Ausdrucks als Kernkonstanteausdruck werden alle Identifikatorausdrücke und Verwendungen von * this , die sich auf ein Objekt oder eine Referenz beziehen, deren Lebensdauer außerhalb der Auswertung des Ausdrucks begann, so behandelt, als würden sie sich auf eine spezifische Instanz dieses Objekts oder dieser Referenz beziehen, deren Lebensdauer und die aller Teilobjekte (einschließlich aller Union-Mitglieder) die gesamte Konstantenauswertung umfasst.

• Für ein solches Objekt das nicht in konstanten Ausdrücken verwendbar ist (seit C++20) , ist der dynamische Typ des Objekts constexpr-unknown .
• Für eine solche Referenz die nicht in konstanten Ausdrücken verwendbar ist (seit C++20) , wird die Referenz so behandelt, als würde sie an ein nicht näher spezifiziertes Objekt des referenzierten Typs gebunden, dessen Lebensdauer und die aller Unterobjekte die gesamte konstante Auswertung umfasst und dessen dynamischer Typ constexpr-unknown ist.

Integraler konstanter Ausdruck

Integraler konstanter Ausdruck ist ein Ausdruck vom integralen oder unbegrenzten Aufzählungstyp, der implizit in einen Prvalue konvertiert wird, wobei der konvertierte Ausdruck ein Kernkonstanter Ausdruck ist.

Wenn ein Ausdruck vom Klassentyp an einer Stelle verwendet wird, wo ein integraler konstanter Ausdruck erwartet wird, wird der Ausdruck kontextuell implizit konvertiert zu einem integralen Typ oder einem unbegrenzten Aufzählungstyp.

Konvertierter konstanter Ausdruck

Ein konvertierter konstanter Ausdruck vom Typ T ist ein Ausdruck, der implizit konvertiert wird zum Typ T , wobei der konvertierte Ausdruck ein konstanter Ausdruck ist und die implizite Konvertierungssequenz nur folgende Elemente enthält:

• constexpr benutzerdefinierte Konvertierungen
• Lvalue-zu-Rvalue-Konvertierungen
• Ganzzahlpromotionen
• nicht-verengende Ganzzahlkonvertierungen
• Gleitkommapromotionen
• nicht-verengende Gleitkommakonvertierungen

Und falls eine Referenzbindung stattfindet, kann es nur eine direkte Bindung sein.

Die folgenden Kontexte erfordern einen konvertierten konstanten Ausdruck:

• die constant-expression von case labels
• enumerator initializers wenn der zugrundeliegende Typ festgelegt ist
• ganzzahlige und Aufzählungs- (bis C++17) konstante template arguments

Ein kontextuell umgewandelter konstanter Ausdruck vom Typ bool ist ein Ausdruck, der kontextuell zu bool umgewandelt wird , wobei der umgewandelte Ausdruck ein konstanter Ausdruck ist und die Umwandlungssequenz nur die oben genannten Konvertierungen enthält.

Die folgenden Kontexte erfordern einen kontextuell konvertierten konstanten Ausdruck vom Typ bool :

• noexcept Spezifikationen

Für die konstante Auswertung benötigte Funktionen und Variablen

Folgende Ausdrücke oder Konvertierungen sind potenziell konstant ausgewertet :

• offensichtlich konstant ausgewertete Ausdrücke
• potenziell ausgewertete Ausdrücke
• unmittelbare Teilausdrücke eines geschweiften Initialisiererlist (konstante Auswertung kann notwendig sein um zu bestimmen ob eine Konvertierung einschränkend ist )
• Adressoperator-Ausdrücke die innerhalb einer templatisierten Entität auftreten (konstante Auswertung kann notwendig sein um zu bestimmen ob ein solcher Ausdruck wertabhängig ist)
• Teilausdrücke eines der obigen die kein Teilausdruck eines verschachtelten nicht ausgewerteten Operanden sind

Eine Funktion ist für konstante Auswertung benötigt wenn sie eine constexpr-Funktion ist und benannt durch einen Ausdruck, der potenziell konstant ausgewertet wird.

Eine Variable ist für konstante Auswertung benötigt wenn sie entweder eine constexpr-Variable ist oder einen nicht-flüchtigen const-qualifizierten integralen Typ oder Referenztyp hat und der Identifikatorausdruck der sie bezeichnet potenziell konstant ausgewertet wird.

Definition einer defaulted-Funktion und Instanziierung einer Funktions-Template -Spezialisierung oder Variablen-Template -Spezialisierung (since C++14) werden ausgelöst, wenn die Funktion oder Variable (since C++14) für konstante Auswertung benötigt wird.

Konstanter Teilausdruck

Ein konstanter Teilausdruck ist ein Ausdruck, dessen Auswertung als Teilausdruck eines Ausdrucks e nicht verhindern würde, dass e ein Core Constant Expression ist, wobei e keiner der folgenden Ausdrücke ist:

• throw Ausdruck

• Zuweisungsausdruck
• Komma-Ausdruck

Hinweise

Beispiel

Fehlerberichte

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

Siehe auch