Constant expressions

Définit une expression qui peut être évaluée à la compilation.

De telles expressions peuvent être utilisées comme arguments de template constants, tailles de tableaux, et dans d'autres contextes nécessitant des expressions constantes, par exemple.

int n = 1;
std::array<int, n> a1;  // Erreur : « n » n'est pas une expression constante
const int cn = 2;
std::array<int, cn> a2; // OK : « cn » est une expression constante

Définition

Lors de la détermination si une expression est une expression constante, l'élision de copie est supposée ne pas être effectuée.

La définition C++98 des expressions constantes se trouve entièrement dans la boîte repliable. La description suivante s'applique à C++11 et aux versions ultérieures de C++.

Type littéral

Les types suivants sont collectivement appelés types littéraux :

• éventuellement qualifié cv void
• type scalaire
• type référence
• un tableau de type littéral
• type de classe éventuellement qualifié cv qui satisfait toutes les conditions suivantes :

• Il possède un destructeur trivial (jusqu'en C++20) constexpr destructeur (depuis C++20) .
• Tous ses membres de données non statiques non-variants et classes de base sont de types littéraux non-volatils.
• C'est l'un des types suivants :

• un type union agrégé qui satisfait l'une des conditions suivantes :

• Il n'a pas de membre variant .
• Il a au moins un membre variant de type littéral non volatile.

• un type agrégé non union, et chacun de ses membres union anonyme satisfait l'une des conditions suivantes :

• Il n'a pas de membre variant.
• Il a au moins un membre variant de type littéral non volatile.

• un type avec au moins un constexpr constructeur (template) qui n'est pas un constructeur de copie ou de déplacement

Seuls les objets de types littéraux peuvent être créés dans une expression constante.

Expression constante de base

Une expression constante de base est toute expression dont l'évaluation ne devrait pas évaluer l'une quelconque des constructions de langage suivantes :

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() est constexpr
   constexpr int m = std::time(nullptr); // Erreur : std::time() n'est pas 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 fonction/constructeur constexpr 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 indéfini ou erroné (depuis C++26) behavior, except for any potential undefined behavior introduced by attributs standard .

   constexpr double d1 = 2.0 / 1.0; // OK
   constexpr double d2 = 2.0 / 0.0; // Erreur : non défini
   constexpr int n = std::numeric_limits<int>::max() + 1; // Erreur : dépassement
   int x, y, z[30];
   constexpr auto e1 = &y - &x;        // Erreur : indéfini
   constexpr auto e2 = &z[20] - &z[3]; // OK
   constexpr std::bitset<2> a; 
   constexpr bool b = a[2]; // Comportement indéfini, mais non spécifié si détecté

7. (jusqu'à C++17) a expression lambda
8. an lvalue-to-rvalue conversion implicite unless applied to...
   1. une glvalue de type (éventuellement qualifié cv) std::nullptr_t
   2. une glvalue de type littéral non volatile qui désigne un objet utilisable dans les expressions constantes

      int main()
      {
          const std::size_t tabsize = 50;
          int tab[tabsize]; // OK: tabsize est une expression constante
                            // car tabsize est utilisable dans les expressions constantes
                            // car il a un type intégral qualifié const, et
                            // son initialiseur est un initialiseur constant
          std::size_t n = 50;
          const std::size_t sz = n;
          int tab2[sz]; // Erreur: sz n'est pas une expression constante
                        // car sz n'est pas utilisable dans les expressions constantes
                        // car son initialiseur n'était pas un initialiseur constant
      }

   3. une glvalue de type littéral non volatile qui fait référence à un objet non volatile dont la durée de vie a commencé durant l'évaluation de cette expression
9. an lvalue-to-rvalue conversion implicite 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 dont la valeur est indéterminée
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. (jusqu'à C++20) an assignment expression that would change the active member of a union
13. conversion from pointeur vers void to a pointer-to-object type T* sauf si le pointeur contient une valeur de pointeur nul ou pointe vers un objet dont le type est similaire à T (depuis C++26)
14. dynamic_cast dont l'opérande est une glvalue qui fait référence à un objet dont le type dynamique est constexpr-inconnu (depuis C++20)
15. reinterpret_cast
16. (jusqu'à C++20) pseudo-destructor call
17. (jusqu'à C++14) an increment or a decrement operator
18. (depuis 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); // Erreur : incr(k) n'est pas une expression constante de base
                                   // car la durée de vie de k
                                   // a commencé en dehors de l'expression incr(k)
        return x;
    }
    constexpr int h(int k)
    {
        int x = incr(k); // OK : x n'est pas requis d'être initialisé
                         // avec une expression constante de base
        return x;
    }
    constexpr int y = h(1); // OK : initialise y avec la valeur 2
                            // h(1) est une expression constante de base car
                            // la durée de vie de k commence à l'intérieur de l'expression h(1)

19. (depuis 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 et que cette glvalue fait référence à un objet dont le type dynamique est constexpr-inconnu (depuis C++20)
21. a new expression , sauf si l'une des conditions suivantes est satisfaite : (depuis C++20)

    La fonction d'allocation sélectionnée est une fonction d'allocation globale remplaçable et le stockage alloué est désalloué durant l'évaluation de cette expression.

    (depuis C++20)

    La fonction d'allocation sélectionnée est une forme non-allouante avec un type alloué T , et l'argument de placement satisfait toutes les conditions suivantes : Il pointe vers : un objet dont le type est similaire à T , si T n'est pas un type tableau, ou le premier élément d'un objet d'un type similaire à T , si T est un type tableau. Il pointe vers un stockage dont la durée a commencé durant l'évaluation de cette expression.

    (depuis C++26)

22. a delete expression , sauf s'il désalloue une région de mémoire allouée durant l'évaluation de cette expression (depuis C++20)
23. (depuis C++20) Coroutines: an expression await or a expression-yield
24. (depuis C++20) a comparaison à trois voies when the result is unspecified
25. an equality or relational operator whose result is unspecified
26. (jusqu'en C++14) an assignment or a compound assignment operator
27. (jusqu'au C++26) une expression throw
28. (depuis C++26) une construction d'un objet exception, sauf si l'objet exception et toutes ses copies implicites créées par les invocations de std::current_exception ou std::rethrow_exception sont détruits durant l'évaluation de cette expression

    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 depuis C++26
    static_assert(always_throw()); // Erreur : exception non capturée

29. une déclaration asm
30. une invocation de la macro va_arg
31. une instruction goto
32. une expression dynamic_cast ou typeid ou une expression new (depuis C++26) qui lancerait une exception où aucune définition du type d'exception n'est accessible (depuis C++26)
33. dans une expression lambda, une référence à this ou à une variable définie à l'extérieur de cette lambda, si cette référence constituerait une odr-use

    void g()
    {
        const int n = 0;
        constexpr int j = *&n; // OK : en dehors d'une expression lambda
        [=]
        {
            constexpr int i = n;   // OK : 'n' n'est pas odr-used et n'est pas capturé ici
            constexpr int j = *&n; // Mal formé : '&n' serait une odr-use de 'n'
        };
    }

    notez que si l'odr-use a lieu dans un appel de fonction à une closure, il ne se réfère pas à this ou à une variable englobante, car il accède à un membre de données de la closure à la place // OK : 'v' & 'm' sont odr-used mais n'apparaissent pas dans une expression constante // dans la lambda imbriquée auto monad = [](auto v){ return [=]{ return v; }; }; auto bind = [](auto m){ return [=](auto fvm){ return fvm(m()); }; }; // OK d'avoir des captures vers des objets automatiques créés durant l'évaluation d'expression constante static_assert(bind(monad(2))(monad)() == monad(2)());

    (depuis C++17)

Exigences supplémentaires

Même si une expression E n'évalue rien de ce qui est mentionné ci-dessus, il est défini par l'implémentation si E est une expression constante de base si l'évaluation de E entraînerait un comportement indéfini à l'exécution .

Même si une expression E n'évalue rien de ce qui est mentionné ci-dessus, il n'est pas spécifié si E est une expression constante de base si l'évaluation de E évaluerait l'un des éléments suivants :

• Une opération avec un comportement non défini dans la bibliothèque standard .
• Un appel de la macro va_start .

Pour déterminer si une expression est une expression constante de base, l'évaluation du corps d'une fonction membre de std:: allocator < T > est ignorée si T est un type littéral.

Aux fins de déterminer si une expression est une expression constante de base, l'évaluation d'un appel à un constructeur de copie/déplacement trivial ou à un opérateur d'affectation de copie/déplacement d'une union est considérée comme copiant/déplaçant le membre actif de l'union, s'il existe.

Lors de l'évaluation de l'expression en tant qu'expression constante de base, toutes les expressions d'identificateur et les utilisations de * this qui se réfèrent à un objet ou une référence dont la durée de vie a commencé en dehors de l'évaluation de l'expression sont traitées comme se référant à une instance spécifique de cet objet ou de cette référence dont la durée de vie et celle de tous les sous-objets (y compris tous les membres d'union) inclut l'ensemble de l'évaluation constante.

• Pour un tel objet qui n'est pas utilisable dans les expressions constantes (depuis C++20) , le type dynamique de l'objet est constexpr-unknown .
• Pour une telle référence qui n'est pas utilisable dans les expressions constantes (depuis C++20) , la référence est traitée comme liée à un objet non spécifié du type référencé dont la durée de vie et celle de tous les sous-objets inclut l'ensemble de l'évaluation constante et dont le type dynamique est constexpr-unknown.

Expression constante entière

Expression constante entière est une expression de type entier ou de type énumération non-scopée implicitement convertie en prvalue, où l'expression convertie est une expression constante de base.

Si une expression de type classe est utilisée là où une expression constante intégrale est attendue, l'expression est implicitement convertie contextuellement en un type intégral ou énumération non délimitée.

Expression constante convertie

Une expression constante convertie de type T est une expression implicitement convertie vers le type T , où l'expression convertie est une expression constante, et la séquence de conversion implicite contient seulement :

• constexpr conversions définies par l'utilisateur
• conversions lvalue-vers-rvalue
• promotions intégrales
• non-rétrécissantes conversions intégrales
• promotions en virgule flottante
• non-rétrécissantes conversions en virgule flottante

Et si une liaison de référence a lieu, elle ne peut être qu'une liaison directe .

Les contextes suivants nécessitent une expression constante convertie :

• l' constant-expression des case labels
• enumerator initializers lorsque le type sous-jacent est fixe
• arguments de template (until C++17) constants template arguments entiers et énumérés

Une expression constante contextuellement convertie de type bool est une expression, contextuellement convertie en bool , où l'expression convertie est une expression constante et la séquence de conversion contient uniquement les conversions mentionnées ci-dessus.

Les contextes suivants nécessitent une expression constante convertie contextuellement de type bool :

• noexcept spécifications

Fonctions et variables nécessaires pour l'évaluation constante

Les expressions ou conversions suivantes sont potentiellement évaluées de manière constante :

• expressions manifestement évaluées constantes
• expressions potentiellement évaluées
• sous-expressions immédiates d'un initialiseur entre accolades (l'évaluation constante peut être nécessaire pour déterminer si une conversion est rétrécissante )
• expressions d'adressage qui apparaissent dans une entité template (l'évaluation constante peut être nécessaire pour déterminer si une telle expression est dépendante en valeur )
• sous-expressions de l'un des éléments ci-dessus qui ne sont pas des sous-expressions d'un opérande non évalué imbriqué

Une fonction est nécessaire pour l'évaluation constante si c'est une fonction constexpr et nommée par une expression potentiellement évaluée de manière constante.

Une variable est nécessaire pour l'évaluation constante si elle est soit une variable constexpr, soit de type intégral qualifié const non volatile ou de type référence, et que l' expression d'identifiant qui la désigne est potentiellement évaluée de manière constante.

Définition d'une fonction par défaut et instanciation d'une function template specialization ou variable template specialization (since C++14) sont déclenchées si la fonction ou variable (since C++14) est nécessaire pour l'évaluation constante.

Sous-expression constante

Une sous-expression constante est une expression dont l'évaluation en tant que sous-expression d'une expression e n'empêcherait pas e d'être une expression constante fondamentale , où e n'est aucune des expressions suivantes :

• throw expression

• expression d'assignation
• expression virgule

Notes

Exemple

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

Voir aussi