std::is_constant_evaluated

 

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

 

Dienstprogramm-Bibliotheken

Sprachunterstützung Typunterstützung (Basistypen, RTTI) Bibliotheks-Feature-Test-Makros (C++20) Programm-Dienstprogramme Variadische Funktionen initializer_list (C++11) is_constant_evaluated (C++20) is_within_lifetime (C++26) source_location (C++20) Coroutine-Unterstützung (C++20) Vertragsunterstützung (C++26) Drei-Wege-Vergleich three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20)   is_eqis_ltis_lteq (C++20)(C++20)(C++20)   is_neqis_gtis_gteq (C++20)(C++20)(C++20)

Allgemeine Hilfsmittel Funktionsobjekte Bit-Manipulation (C++20) bitset hash (C++11) Relationale Operatoren (in C++20 veraltet) rel_ops::operator!=rel_ops::operator>    rel_ops::operator<=rel_ops::operator>= Ganzzahl-Vergleichsfunktionen cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20)   cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) Swap und Typ-Operationen swap ranges::swap (C++20) exchange (C++14) declval (C++11) to_underlying (C++23) forward (C++11) forward_like (C++23) move (C++11) move_if_noexcept (C++11) as_const (C++17) Gemeinsame Vokabulartypen pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) expected (C++23)

 

Definiert in der Kopfdatei <type_traits>
constexpr bool is_constant_evaluated() noexcept;		(seit C++20)

Ermittelt, ob der Funktionsaufruf innerhalb eines konstant ausgewerteten Kontexts erfolgt. Gibt true zurück, wenn die Auswertung des Aufrufs innerhalb der Auswertung eines Ausdrucks oder einer Konvertierung erfolgt, der explizit konstant ausgewertet wird; andernfalls wird false zurückgegeben.

Um zu bestimmen, ob Initialisierer von folgenden Variablen explizit konstant ausgewertet werden, können Compiler zunächst eine Probekonstantenauswertung durchführen.

• Variablen mit Referenztyp oder const-qualifiziertem ganzzahligem oder Aufzählungstyp;
• 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;
// Trial constant evaluation fails. The constant evaluation is discarded.
// Variable a is dynamically initialized with 1
 
const int b = std::is_constant_evaluated() ? 2 : y;
// Constant evaluation with std::is_constant_evaluated() == true succeeds.
// Variable b is statically initialized with 2

Parameter

(keine)

Rückgabewert

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

Mögliche Implementierung

// This implementation requires C++23 if consteval. constexpr bool is_constant_evaluated() noexcept { if consteval { return true; } else { return false; } }

Hinweise

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

Da if consteval in C++20 fehlt, wird std::is_constant_evaluated typischerweise mithilfe einer Compilererweiterung implementiert.

Feature-Test-Makro	Wert	Std	Feature
__cpp_lib_is_constant_evaluated	201811L	(C++20)	std::is_constant_evaluated

Beispiel

Führen Sie diesen Code aus

#include <cmath>
#include <iostream>
#include <type_traits>
 
constexpr double power(double b, int x)
{
    if (std::is_constant_evaluated() && !(b == 0.0 && x < 0))
    {
        // A constant-evaluation context: Use a constexpr-friendly algorithm.
        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
    {
        // Let the code generator figure it out.
        return std::pow(b, double(x));
    }
}
 
int main()
{
    // A constant-expression context
    constexpr double kilo = power(10.0, 3);
    int n = 3;
    // Not a constant expression, because n cannot be converted to an rvalue
    // in a constant-expression context
    // Equivalent to std::pow(10.0, double(n))
    double mucho = power(10.0, n);
 
    std::cout << kilo << " " << mucho << "\n"; // (3)
}

Ausgabe

1000 1000

Siehe auch

constexpr-Spezifizierer(C++11)	gibt an, dass der Wert einer Variablen oder Funktion zur Kompilierzeit berechnet werden kann
consteval-Spezifizierer(C++20)	gibt an, dass eine Funktion eine unmittelbare Funktion ist, d. h., jeder Aufruf der Funktion muss in einer konstanten Auswertung erfolgen
constinit-Spezifizierer(C++20)	stellt sicher, dass eine Variable eine statische Initialisierung hat, d. h. Null-Initialisierung und konstante Initialisierung