Целочисленный литерал

Позволяет использовать значения целочисленного типа непосредственно в выражениях.

Синтаксис

Целочисленный литерал имеет следующую форму:

где:

• decimal-literal — ненулевая десятичная цифра (1, 2, 3, 4, 5, 6, 7, 8, 9), за которой следует ноль или более десятичных цифр (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
• octal-literal — цифра ноль (0), за которой следует ноль или более восьмеричных цифр (0, 1, 2, 3, 4, 5, 6, 7)
• hex-literal — последовательность символов 0x или последовательность символов 0X, за которой следует одна или более шестнадцатеричных цифр (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, A, b, B, c, C, d, D, e, E, f, F)
• binary-literal — последовательность символов 0b или последовательность символов 0B, за которой следует одна или более двоичных цифр (0, 1)
• integer-suffix, если указан, может содержать один или оба из следующих суффиксов (если указаны оба, они могут располагаться в любом порядке):
• unsigned-suffix (символ u или символ U)
• один из следующих:
• long-suffix (символ l или символ L)

Целочисленный литерал, как и любой другой литерал, является первичным выражением.

Пояснение

Первая цифра целочисленного литерала является старшей.

Пример. Следующие переменные инициализируются одинаковым значением:

int d = 42;
int o = 052;
int x = 0x2a;
int X = 0X2A;
int b = 0b101010; // C++14

Пример. Следующие переменные также инициализируются одинаковым значением:

unsigned long long l1 = 18446744073709550592ull;       // C++11
unsigned long long l2 = 18'446'744'073'709'550'592llu; // C++14
unsigned long long l3 = 1844'6744'0737'0955'0592uLL;   // C++14
unsigned long long l4 = 184467'440737'0'95505'92LLU;   // C++14

Тип литерала

Типом целочисленного литерала является первый тип из списка типов, в который помещается его значение. Список зависит от используемого основания системы счисления и суффикса integer-suffix:

Если значение целочисленного литерала без суффикса size-suffix(начиная с C++23) слишком велико, чтобы поместиться в любой из типов, допустимых для сочетания суффикса и основания, и компилятор поддерживает расширенный целочисленный тип (например, __int128), который может представлять значение литерала, литералу может быть присвоен этот расширенный целочисленный тип; в противном случае программа некорректна.

Примечания

Буквы в целочисленных литералах не различают регистр: 0xDeAdBeEfU и 0XdeadBEEFu обозначают одно и то же число (одно исключение — суффикс long-long-suffix, который записывается либо как ll, либо как LL, но никогда как lL или Ll)(начиная с C++11).

Отрицательных целочисленных литералов не существует. В выражениях, таких как -1, к значению, представленному литералом, применяется унарный оператор минус, что может повлечь неявные преобразования типов.

В C до C99 (но не в C++) беззнаковые десятичные значения без суффикса, не помещающиеся в longint, могут иметь тип unsignedlongint.

Из-за правила максимального захвата шестнадцатеричные целочисленные литералы, заканчивающиеся на e и E, если за ними следуют операторы + или -, должны быть отделены от оператора пробелами или скобками в исходном коде:

auto x = 0xE+2.0;   // error
auto y = 0xa+2.0;   // OK
auto z = 0xE +2.0;  // OK
auto q = (0xE)+2.0; // OK

В противном случае образуется единый недопустимый токен препроцессорного числа, из-за которого дальнейший анализ завершается ошибкой.

Пример

#include <cstddef>
#include <iostream>
#include <type_traits>

int main()
{
    std::cout << 123 << '\n'
              << 0123 << '\n'
              << 0x123 << '\n'
              << 0b10 << '\n'
              << 12345678901234567890ull << '\n'
              << 12345678901234567890u << '\n'; // the type is unsigned long long
                                                // even without a long long suffix

//  std::cout << -9223372036854775808 << '\n'; // error: the value
               // 9223372036854775808 cannot fit in signed long long, which is the
               // biggest type allowed for unsuffixed decimal integer literal
    std::cout << -9223372036854775808u << '\n'; // unary minus applied to unsigned
               // value subtracts it from 2^64, this gives 9223372036854775808
    std::cout << -9223372036854775807 - 1 << '\n'; // correct way to calculate
                                                   // the value -9223372036854775808

#if __cpp_size_t_suffix >= 202011L // C++23
    static_assert(std::is_same_v<decltype(0UZ), std::size_t>);
    static_assert(std::is_same_v<decltype(0Z), std::make_signed_t<std::size_t>>);
#endif
}

123
83
291
2
12345678901234567890
12345678901234567890
9223372036854775808
-9223372036854775808

Отчёты об ошибках

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

Ссылки

• Стандарт C++23 (ISO/IEC 14882:2024):
• 5.13.2 Целочисленные литералы [lex.icon]
• Стандарт C++20 (ISO/IEC 14882:2020):
• 5.13.2 Целочисленные литералы [lex.icon]
• Стандарт C++17 (ISO/IEC 14882:2017):
• 5.13.2 Целочисленные литералы [lex.icon]
• Стандарт C++14 (ISO/IEC 14882:2014):
• 2.14.2 Целочисленные литералы [lex.icon]
• Стандарт C++11 (ISO/IEC 14882:2011):
• 2.14.2 Целочисленные литералы [lex.icon]
• Стандарт C++98 (ISO/IEC 14882:1998):
• 2.13.1 Целочисленные литералы [lex.icon]

См. также