constexpr specifier (since C++11)

• constexpr - указывает, что значение переменной , structured binding (since C++26) или функции может использоваться в constant expressions

Объяснение

Спецификатор constexpr объявляет, что значение сущности может быть вычислено во время компиляции. Такие сущности могут затем использоваться там, где допускаются только константные выражения времени компиляции (при условии передачи соответствующих аргументов функции).

Спецификатор constexpr , используемый в объявлении объекта или нестатической функции-члена (до C++14) , подразумевает const .

Спецификатор constexpr , используемый в первом объявлении функции или static члена данных (начиная с C++17) , подразумевает inline . Если любое объявление функции или шаблона функции содержит спецификатор constexpr , то каждое объявление должно содержать этот спецификатор.

constexpr переменная

Переменная или шаблон переменной (начиная с C++14) может быть объявлена constexpr если выполняются все следующие условия:

• Объявление является определением .
• Оно имеет literal type .
• Оно инициализируется (объявлением).

constexpr функция

Функция или шаблон функции может быть объявлен constexpr .

Функция является constexpr-подходящей если выполняются все следующие условия:

• Если это конструктор или деструктор (начиная с C++20) , его класс не имеет никаких виртуальных базовых классов .

За исключением инстанцированных constexpr функций, нешаблонные constexpr функции должны быть constexpr-совместимыми.

Вызов constexpr функции в заданном контексте дает тот же результат, что и вызов эквивалентной не- constexpr функции в том же контексте во всех отношениях, за следующими исключениями:

• Вызов constexpr функции может появляться в константном выражении .
• Копирование исключений не выполняется в константном выражении.

constexpr конструктор

В дополнение к требованиям для constexpr функций, конструктор также должен удовлетворять всем следующим условиям, чтобы быть подходящим для constexpr:

• Класс не имеет ни одного virtual base class .

constexpr деструктор

Примечания

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 разрешены для классов, которые не являются литеральными типами. Например, конструктор по умолчанию std::shared_ptr является constexpr, что позволяет постоянную инициализацию .

Ссылочные переменные могут быть объявлены как constexpr (их инициализаторы должны быть reference constant expressions ):

static constexpr int const& x = 42; // constexpr ссылка на const int объект
                                    // (объект имеет статическую продолжительность хранения
                                    //  благодаря продлению времени жизни статической ссылкой)

Ключевые слова

constexpr

Пример

#include <iostream>
#include <stdexcept>
// C++11 constexpr функции используют рекурсию вместо итерации
constexpr int factorial(int n)
{
    return n <= 1 ? 1 : (n * factorial(n - 1));
}
// C++14 constexpr функции могут использовать локальные переменные и циклы
#if __cplusplus >= 201402L
constexpr int factorial_cxx14(int n)
{
    int res = 1;
    while (n > 1)
        res *= n--;
    return res;
}
#endif // C++14
// Литеральный класс
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 функции сигнализируют об ошибках, выбрасывая исключения
    // в C++11 они должны делать это через условный оператор ?:
    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 функции должны были помещать всё в один оператор return
// (C++14 не имеет этого требования)
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);
}
// Функция вывода, требующая константу времени компиляции, для тестирования
template<int n>
struct constN
{
    constN() { std::cout << n << '\n'; }
};
int main()
{
    std::cout << "4! = ";
    constN<factorial(4)> out1; // вычисляется во время компиляции
    volatile int k = 8; // запретить оптимизацию с помощью volatile
    std::cout << k << "! = " << factorial(k) << '\n'; // вычисляется во время выполнения
    std::cout << "Количество строчных букв в \"Hello, world!\" равно ";
    constN<countlower("Hello, world!")> out2; // неявно преобразовано в 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) в C++17,
                                                      // std::ssize(a) в C++20
    std::cout << "Массив длиной " << length_a << " содержит элементы: ";
    for (int i = 0; i < length_a; ++i)
        std::cout << a[i] << ' ';
    std::cout << '\n';
}

4! = 24
8! = 40320
Количество строчных букв в "Hello, world!" равно 9
Массив длиной 12 содержит элементы: 0 1 2 3 4 5 6 7 8 0 0 0

Отчеты о дефектах

Следующие отчеты об изменениях поведения, влияющие на дефекты, были применены задним числом к ранее опубликованным стандартам C++.

1. ↑ Это избыточно, потому что не может быть более одного объявления шаблона переменной с constexpr спецификатором.

Смотрите также