std:: is_constant_evaluated

Erkennt, ob der Funktionsaufruf in einem konstant ausgewerteten Kontext stattfindet. Gibt true zurück, wenn die Auswertung des Aufrufs während der Auswertung eines Ausdrucks oder einer Konvertierung erfolgt, der/die offensichtlich konstant ausgewertet wird; andernfalls wird false zurückgegeben.

Um zu bestimmen, ob die Initialisierer der folgenden Variablen offensichtlich konstant ausgewertet werden, können Compiler zunächst eine versuchsweise Konstantenauswertung durchführen:

• Variablen mit Referenztyp oder const-qualifiziertem Integral- oder Enumerationstyp;
• statische und thread-lokale Variablen.

Es wird nicht empfohlen, sich in diesem Fall auf das Ergebnis zu verlassen.

int y = 0;
const int a = std::is_constant_evaluated() ? y : 1;
// Versuch der konstanten Auswertung schlägt fehl. Die konstante Auswertung wird verworfen.
// Variable a wird dynamisch mit 1 initialisiert
const int b = std::is_constant_evaluated() ? 2 : y;
// Konstante Auswertung mit std::is_constant_evaluated() == true erfolgreich.
// Variable b wird statisch mit 2 initialisiert

Parameter

(keine)

Rückgabewert

true wenn die Auswertung des Aufrufs innerhalb der Auswertung eines Ausdrucks oder einer Konvertierung erfolgt, die offensichtlich konstant ausgewertet wird; andernfalls false .

Mögliche Implementierung

// Diese Implementierung erfordert C++23 if consteval.
constexpr bool is_constant_evaluated() noexcept
{
    if consteval
    {
        return true;
    }
    else 
    {
        return false;
    }
}

Hinweise

Wenn direkt als Bedingung einer static_assert -Deklaration oder einer constexpr-if-Anweisung verwendet, gibt std :: is_constant_evaluated ( ) immer true zurück.

Weil if consteval in C++20 nicht vorhanden ist, wird std::is_constant_evaluated typischerweise über eine Compiler-Erweiterung implementiert.

Beispiel

#include <cmath>
#include <iostream>
#include <type_traits>
constexpr double power(double b, int x)
{
    if (std::is_constant_evaluated() && !(b == 0.0 && x < 0))
    {
        // Ein Kontext für konstante Auswertung: Verwende einen constexpr-freundlichen Algorithmus.
        if (x == 0)
            return 1.0;
        double r {1.0};
        double p {x > 0 ? b : 1.0 / b};
        for (auto u = unsigned(x > 0 ? x : -x); u != 0; u /= 2)
        {
            if (u & 1)
                r *= p;
            p *= p;
        }
        return r;
    }
    else
    {
        // Lässt den Codegenerator die Lösung finden.
        return std::pow(b, double(x));
    }
}
int main()
{
    // Ein Kontext für konstante Ausdrücke
    constexpr double kilo = power(10.0, 3);
    int n = 3;
    // Kein konstanter Ausdruck, da n im Kontext eines konstanten Ausdrucks
    // nicht in einen Rvalue konvertiert werden kann
    // Entspricht std::pow(10.0, double(n))
    double mucho = power(10.0, n);
    std::cout << kilo << " " << mucho << "\n"; // (3)
}

1000 1000

Siehe auch