constexpr specifier (since C++11)

• constexpr - spécifie que la valeur d'une variable , structured binding (depuis C++26) ou d'une fonction peut apparaître dans des expressions constantes

Explication

Le spécificateur constexpr déclare qu'il est possible d'évaluer la valeur des entités au moment de la compilation. Ces entités peuvent ensuite être utilisées là où seules les expressions constantes de compilation sont autorisées (à condition que des arguments de fonction appropriés soient fournis).

Un spécificateur constexpr utilisé dans une déclaration d'objet ou de fonction membre non statique (jusqu'en C++14) implique const .

Un spécificateur constexpr utilisé dans la première déclaration d'une fonction ou d'un membre de données statique (depuis C++17) implique inline . Si une déclaration d'une fonction ou d'un modèle de fonction possède un spécificateur constexpr , alors chaque déclaration doit contenir ce spécificateur.

constexpr variable

Une variable ou un modèle de variable (depuis C++14) peut être déclarée constexpr si toutes les conditions suivantes sont satisfaites :

• La déclaration est une définition .
• Elle est d'un literal type .
• Elle est initialisée (par la déclaration).

constexpr fonction

Une fonction ou un modèle de fonction peut être déclaré constexpr .

Une fonction est constexpr-suitable si toutes les conditions suivantes sont satisfaites :

• S'il s'agit d'un constructeur ou d'un destructeur (depuis C++20) , sa classe n'a pas de classe de base virtuelle .

Sauf pour les fonctions constexpr instanciées, les fonctions non-templatisées constexpr doivent être adaptées pour constexpr.

Un appel d'une fonction constexpr dans un contexte donné produit le même résultat qu'un appel d'une fonction non- constexpr équivalente dans le même contexte à tous égards, avec les exceptions suivantes :

• Un appel d'une fonction constexpr peut apparaître dans une expression constante .
• L'élision de copie n'est pas effectuée dans une expression constante.

constexpr constructeur

En plus des exigences des fonctions constexpr , un constructeur doit également satisfaire à toutes les conditions suivantes pour être adapté à constexpr :

• La classe n'a aucune virtual base class .

constexpr destructeur

Notes

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
}

Les constructeurs constexpr sont autorisés pour les classes qui ne sont pas des types littéraux. Par exemple, le constructeur par défaut de std::shared_ptr est constexpr, permettant une initialisation constante .

Les variables de référence peuvent être déclarées constexpr (leurs initialiseurs doivent être des expressions constantes de référence ) :

static constexpr int const& x = 42; // référence constexpr vers un objet const int
                                    // (l'objet a une durée de stockage statique
                                    //  en raison de l'extension de durée de vie par une référence statique)

Mots-clés

constexpr

Exemple

#include <iostream>
#include <stdexcept>
// Les fonctions constexpr de C++11 utilisent la récursion plutôt que l'itération
constexpr int factorial(int n)
{
    return n <= 1 ? 1 : (n * factorial(n - 1));
}
// Les fonctions constexpr de C++14 peuvent utiliser des variables locales et des boucles
#if __cplusplus >= 201402L
constexpr int factorial_cxx14(int n)
{
    int res = 1;
    while (n > 1)
        res *= n--;
    return res;
}
#endif // C++14
// Une classe littérale
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) {}
    // Les fonctions constexpr signalent les erreurs en lançant des exceptions
    // En C++11, elles doivent le faire depuis l'opérateur conditionnel ?:
    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; }
};
// Les fonctions constexpr de C++11 devaient tout mettre dans une seule instruction return
// (C++14 n'a pas cette exigence)
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);
}
// Une fonction de sortie qui nécessite une constante à la compilation, pour les tests
template<int n>
struct constN
{
    constN() { std::cout << n << '\n'; }
};
int main()
{
    std::cout << "4! = ";
    constN<factorial(4)> out1; // calculé à la compilation
    volatile int k = 8; // empêche l'optimisation en utilisant volatile
    std::cout << k << "! = " << factorial(k) << '\n'; // calculé à l'exécution
    std::cout << "Le nombre de lettres minuscules dans \"Hello, world!\" est ";
    constN<countlower("Hello, world!")> out2; // implicitement converti en conststr
    constexpr int a[12] = {0, 1, 2, 3, 4, 5, 6, 7, 8};
    constexpr int length_a = sizeof a / sizeof(int); // std::size(a) en C++17,
                                                      // std::ssize(a) en C++20
    std::cout << "Le tableau de longueur " << length_a << " a pour éléments : ";
    for (int i = 0; i < length_a; ++i)
        std::cout << a[i] << ' ';
    std::cout << '\n';
}

4! = 24
8! = 40320
Le nombre de lettres minuscules dans "Hello, world!" est 9
Un tableau de longueur 12 a pour éléments : 0 1 2 3 4 5 6 7 8 0 0 0

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.

1. ↑ C'est redondant car il ne peut y avoir plus d'une déclaration d'un modèle de variable avec le spécificateur constexpr .

Voir aussi