constexpr specifier (since C++11)

• constexpr - gibt an, dass der Wert einer Variable , structured binding (since C++26) oder Funktion in constant expressions erscheinen kann

Erklärung

Der constexpr -Spezifizierer deklariert, dass es möglich ist, den Wert der Entitäten zur Übersetzungszeit auszuwerten. Solche Entitäten können dann verwendet werden, wo nur konstante Ausdrücke zur Übersetzungszeit erlaubt sind (sofern entsprechende Funktionsargumente gegeben sind).

Ein constexpr -Spezifizierer, der in einer Objektdeklaration oder nicht-statischen Memberfunktion (bis C++14) verwendet wird, impliziert const .

Ein constexpr Spezifizierer, der in der ersten Deklaration einer Funktion oder eines static Datenelements (seit C++17) verwendet wird, impliziert inline . Wenn eine Deklaration einer Funktion oder Funktionsvorlage einen constexpr Spezifizierer besitzt, dann muss jede Deklaration diesen Spezifizierer enthalten.

constexpr Variable

Eine Variable oder Variablen-Template (seit C++14) kann als constexpr deklariert werden, wenn alle folgenden Bedingungen erfüllt sind:

• Die Deklaration ist eine Definition .
• Sie ist von einem literal type .
• Sie wird (durch die Deklaration) initialisiert.

constexpr Funktion

Eine Funktion oder Funktionsvorlage kann als constexpr deklariert werden.

Eine Funktion ist constexpr-suitable wenn alle folgenden Bedingungen erfüllt sind:

• Wenn es ein Konstruktor oder Destruktor (seit C++20) ist, hat seine Klasse keine virtuelle Basisklasse .

Mit Ausnahme von instanziierten constexpr Funktionen müssen nicht-templatisierte constexpr Funktionen constexpr-tauglich sein.

Ein Aufruf einer constexpr -Funktion in einem bestimmten Kontext erzeugt in jeder Hinsicht dasselbe Ergebnis wie ein Aufruf einer äquivalenten Nicht- constexpr -Funktion im selben Kontext, mit folgenden Ausnahmen:

• Ein Aufruf einer constexpr -Funktion kann in einem konstanten Ausdruck erscheinen.
• Copy Elision wird nicht in einem konstanten Ausdruck durchgeführt.

constexpr Konstruktor

Zusätzlich zu den Anforderungen an constexpr -Funktionen muss ein Konstruktor alle folgenden Bedingungen erfüllen, um für constexpr geeignet zu sein:

• Die Klasse hat keine virtuelle Basisklasse .

constexpr Destruktor

Hinweise

constexpr int f(); 
constexpr bool b1 = noexcept(f()); // false, undefined constexpr function
constexpr int f() { return 0; }
constexpr bool b2 = noexcept(f()); // true, f() is a constant expression

void f(int& i) // not a constexpr function
{
    i = 0;
}
constexpr void g(int& i) // well-formed since C++23
{
    f(i); // unconditionally calls f, cannot be a constant expression
}

Constexpr-Konstruktoren sind für Klassen erlaubt, die keine Literaltypen sind. Beispielsweise ist der Standardkonstruktor von std::shared_ptr constexpr, was eine konstante Initialisierung ermöglicht.

Referenzvariablen können als constexpr deklariert werden (ihre Initialisierer müssen Referenzkonstantenausdrücke sein):

static constexpr int const& x = 42; // constexpr-Referenz auf ein const int-Objekt
                                    // (das Objekt hat aufgrund der Lebensdauerverlängerung
                                    //  durch eine statische Referenz statische Speicherdauer)

Schlüsselwörter

constexpr

Beispiel

#include <iostream>
#include <stdexcept>
// C++11 constexpr-Funktionen verwenden Rekursion anstelle von Iteration
constexpr int factorial(int n)
{
    return n <= 1 ? 1 : (n * factorial(n - 1));
}
// C++14 constexpr-Funktionen können lokale Variablen und Schleifen verwenden
#if __cplusplus >= 201402L
constexpr int factorial_cxx14(int n)
{
    int res = 1;
    while (n > 1)
        res *= n--;
    return res;
}
#endif // C++14
// Eine Literalklasse
class conststr
{
    const char* p;
    std::size_t sz;
public:
    template<std::size_t N>
    constexpr conststr(const char(&a)[N]): p(a), sz(N - 1) {}
    // constexpr-Funktionen signalisieren Fehler durch Auslösen von Ausnahmen
    // in C++11 müssen sie dies über den bedingten Operator ?: tun
    constexpr char operator[](std::size_t n) const
    {
        return n < sz ? p[n] : throw std::out_of_range("");
    }
    constexpr std::size_t size() const { return sz; }
};
// C++11 constexpr-Funktionen mussten alles in einer einzigen return-Anweisung unterbringen
// (C++14 hat diese Anforderung nicht)
constexpr std::size_t countlower(conststr s, std::size_t n = 0,
                                             std::size_t c = 0)
{
    return n == s.size() ? c :
        'a' <= s[n] && s[n] <= 'z' ? countlower(s, n + 1, c + 1)
                                   : countlower(s, n + 1, c);
}
// Eine Ausgabefunktion, die eine Kompilierzeitkonstante erfordert, zum Testen
template<int n>
struct constN
{
    constN() { std::cout << n << '\n'; }
};
int main()
{
    std::cout << "4! = ";
    constN<factorial(4)> out1; // zur Kompilierzeit berechnet
    volatile int k = 8; // Optimierung mit volatile verhindern
    std::cout << k << "! = " << factorial(k) << '\n'; // zur Laufzeit berechnet
    std::cout << "Die Anzahl der Kleinbuchstaben in \"Hello, world!\" ist ";
    constN<countlower("Hello, world!")> out2; // implizit zu conststr konvertiert
    constexpr int a[12] = {0, 1, 2, 3, 4, 5, 6, 7, 8};
    constexpr int length_a = sizeof a / sizeof(int); // std::size(a) in C++17,
                                                      // std::ssize(a) in C++20
    std::cout << "Array der Länge " << length_a << " hat Elemente: ";
    for (int i = 0; i < length_a; ++i)
        std::cout << a[i] << ' ';
    std::cout << '\n';
}

4! = 24
8! = 40320
Die Anzahl der Kleinbuchstaben in "Hello, world!" ist 9
Array der Länge 12 hat Elemente: 0 1 2 3 4 5 6 7 8 0 0 0

Fehlerberichte

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

1. ↑ Es ist redundant, da es nicht mehr als eine Deklaration einer Variablenvorlage mit dem constexpr Spezifizierer geben kann.

Siehe auch