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

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

Синтаксис

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


десятичный-литерал целочисленный-суффикс (необязательно)	(1)

восьмеричный-литерал целочисленный-суффикс (необязательно)	(2)

шестнадцатеричный-литерал целочисленный-суффикс (необязательно)	(3)

двоичный-литерал целочисленный-суффикс (необязательно)	(4)	(начиная с C++14)

где

десятичный-литерал ненулевая десятичная цифра (1, 2, 3, 4, 5, 6, 7, 8, 9), за которой следует ноль или более десятичных цифр (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
восьмеричный-литерал это цифра ноль (0), за которой следует ноль или более восьмеричных цифр (0, 1, 2, 3, 4, 5, 6, 7)
шестнадцатеричный-литерал это последовательность символов 0x или последовательность символов 0X, за которой следует одна или несколько шестнадцатеричных цифр (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, A, b, B, c, C, d, D, e, E, f, F)
двоичный-литерал это последовательность символов 0b или последовательность символов 0B, за которой следует одна или несколько двоичных цифр (0, 1)
целочисленный-суффикс, если предоставлен, может содержать одно или оба из следующих значений (если оба предоставлены, они могут появляться в любом порядке:

беззнаковый-суффикс (символ u или символ U)
один из

long-суффикс (символ l или символ L)

long-long-суффикс (последовательность символов ll или последовательность символов LL)

(начиная с C++11)

суффикс-размера (символ z или символ Z)

(начиная с C++23)

Необязательные одинарные кавычки (') могут быть вставлены между цифрами в качестве разделителя; они игнорируются при определении значения литерала.

(начиная с C++14)

Целочисленный литерал (как и любой литерал) представляет собой первичное выражение.

Объяснение

1) Десятичный целочисленный литерал (основание 10).

2) Восьмеричный целочисленный литерал (основание 8).

3) Шестнадцатеричный целочисленный литерал (основание 16, буквы от 'a' до 'f' представляют значения (десятичные) от 10 до 15).

4) Двоичный целочисленный литерал (основание 2).

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

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

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

Тип литерала

Тип целочисленного литерала это первый тип, которому может соответствовать значение, из списка типов, которое зависит от того, какая числовая база и какой целочисленный суффикс использовался:

Суффикс	Десятичные основания	Двоичные, восьмеричные или шестнадцатеричные основания
(нет суффикса)	`int` `long int` `long long int` (начиная с C++11)	`int` `unsigned int` `long int` `unsigned long int` `long long int` (начиная с C++11) `unsigned long long int` (начиная с C++11)
`u` или `U`	`unsigned int` `unsigned long int` `unsigned long long int` (начиная с C++11)	`unsigned int` `unsigned long int` `unsigned long long int` (начиная с C++11)
`l` или `L`	`long int` `unsigned long int` (до C++11) `long long int` (начиная с C++11)	`long int` `unsigned long int` `long long int` (начиная с C++11) `unsigned long long int` (начиная с C++11)
`l`/`L` и `u`/`U`	`unsigned long int` `unsigned long long int` (начиная с C++11)	`unsigned long int` `unsigned long long int` (начиная с C++11)
`ll` или `LL`	`long long int` (начиная с C++11)	`long long int` (начиная с C++11) `unsigned long long int` (начиная с C++11)
`ll`/`LL` и `u`/`U`	`unsigned long long int` (начиная с C++11)	`unsigned long long int` (начиная с C++11)
`z` или `Z`	знаковая версия std::size_t (начиная с C++23)	знаковая версия std::size_t (начиная с C++23) std::size_t (начиная с C++23)
`z`/`Z` и `u`/`U`	std::size_t (начиная с C++23)	std::size_t (начиная с C++23)

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

Примечание

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

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

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

При использовании в управляющем выражении #if или #elif все целочисленные константы со знаком действуют так, как если бы они имели тип std::intmax_t и все целочисленные константы без знака действуют так, как если бы они имели тип std::uintmax_t.

(начиная с C++11)

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

auto x = 0xE+2.0;   // ошибка
auto y = 0xa+2.0;   // OK
auto z = 0xE +2.0;  // OK
auto q = (0xE)+2.0; // OK

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

Макрос тест функциональности	Значение	Стандарт	Комментарий
`__cpp_binary_literals`	`201304L`	(C++14)	Двоичные литералы
`__cpp_size_t_suffix`	`202011L`	(C++23)	Литеральные суффиксы для std::size_t и его знаковой версии

Пример

Запустить этот код

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

int main()
{
std::cout << 123    << '\n'
          << 0123   << '\n'
          << 0x123  << '\n'
          << 0b10   << '\n'
          << 12345678901234567890ull << '\n'
          << 12345678901234567890u   << '\n'; // тип unsigned long long даже
                                              // без суффикса long long

//   std::cout << -9223372036854775808 << '\n'; // ошибка: значение
                // 9223372036854775808 не может поместиться в знаковом long long, который
                // является самым большим типом, разрешённым для десятичного
                // целочисленного литерала без суффикса
     std::cout << -9223372036854775808u << '\n'; // унарный минус, примененный к
                // беззнаковому значению, вычитает его из 2^64,
                // это даёт 9223372036854775808
     std::cout << -9223372036854775807 - 1 << '\n'; // правильный способ расчёта
                                                    // значения -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++:

Номер	Применён	Поведение в стандарте	Корректное поведение
CWG 2698	C++23	целочисленный литерал с суффиксом размера может иметь расширенный целочисленный тип	некорретно, если слишком большой

Ссылки

C++23 стандарт (ISO/IEC 14882:2023):

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]

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

определяемые пользователем литералы(C++11)	литералы с пользовательским суффиксом[править]
Документация C по целочисленная константа

Поддержка компилятором
Автономные и размещённые реализации
Язык
Стандартная библиотека
Заголовки стандартной библиотеки
Требования к именованию
Макросы тестирования функциональности (C++20)
Поддержка языка
Библиотека концептов (C++20)
Библиотека метапрограммирования (C++11)
Библиотека диагностики
Библиотека общих утилит
Библиотека строк
Библиотека контейнеров
Библиотека итераторов
Библиотека диапазонов (C++20)
Библиотека алгоритмов
Библиотека численных данных
Библиотека ввода/вывода
Библиотека локализаций
Регулярные выражения (C++11)
Атомарные операции (C++11)
Библиотека поддержки конкуренции (C++11)
Библиотека файловой системы (C++17)
Технические спецификации
Указатель символов
Внешние библиотеки

cppreference.com

Поиск

Пространства имён

Варианты

Просмотры

Действия