Integer literal

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

Синтаксис

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

где

• 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 :

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

Примечания

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

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

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

Из-за максимального поглощения , шестнадцатеричные целочисленные литералы, оканчивающиеся на 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

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

Пример

#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 не помещается в signed 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++.

Ссылки

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