Целочисленная константа

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

Синтаксис

Целочисленная константа — это выражение типа не-lvalue в форме

десятичная-константа целочисленная-приставка (необязательно)	(1)
восьмеричная-константа целочисленная-приставка (необязательно)	(2)
шестнадцатеричная-константа целочисленная-приставка (необязательно)	(3)
двоичная-константа целочисленная-приставка (необязательно)	(4)	(с C23)

где

десятичная-константа — это ненулевая десятичная цифра (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)
длинный-суффикс (символ l или символ L) или очень-длинный-суффикс (последовательность символов ll или последовательность символов LL)(с C99)
точность-int-суффикс (последовательность символов wb или последовательность символов WB) (с C23)

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

(с C23)

Объяснение

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; // C23

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

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

Тип целочисленной константы

Тип целочисленной константы — это первый тип, в котором значение может уместиться, из списка типов, зависящего от используемой числовой системы счисления и целочисленной-приставки.

Допустимые типы для целочисленных констант
приставка	десятичная система	другие системы
без приставки	`int` `long int` `unsigned long int` (до C99) `long long int` (с C99)	`int` `unsigned int` `long int` `unsigned long int` `long long int`(с C99) `unsigned long long int`(с C99)
`u` или `U`	`unsigned int` `unsigned long int` `unsigned long long int`(с C99)	`unsigned int` `unsigned long int` `unsigned long long int`(с C99)
`l` или `L`	`long int` `unsigned long int`(до C99) `long long int`(с C99)	`long int` `unsigned long int` `long long int`(с C99) `unsigned long long int`(с C99)
оба `l`/`L` и `u`/`U`	`unsigned long int` `unsigned long long int`(с C99)	`unsigned long int` `unsigned long long int`(с C99)
`ll` или `LL`	`long long int`(с C99)	`long long int`(с C99) `unsigned long long int`(с C99)
оба `ll`/`LL` и `u`/`U`	`unsigned long long int`(с C99)	`unsigned long long int`(с C99)
`wb` или `WB`	`_BitInt(N)` где ширина N — наименьшее N, большее 1, которое может вместить значение и биты знака(с C23)	`_BitInt(N)` где ширина N — наименьшее N, большее 1, которое может вместить значение и биты знака(с C23)
оба `wb`/`WB` и `u`/`U`	`unsigned _BitInt(N)` где ширина N — наименьшее N, большее 0, которое может вместить значение(с C23)	`unsigned _BitInt(N)` где ширина N — наименьшее N, большее 0, которое может вместить значение(с C23)

Если значение целочисленной константы слишком велико для любого из типов, разрешённых комбинацией приставки/основания, и она не имеет суффиксов wb, WB, uwb, или UWB(с C23) и компилятор поддерживает расширенные целочисленные типы (например, __int128), константа может получить расширенный целочисленный тип; в противном случае программа некорректна.

Примечания

Регистр букв в целочисленных константах не важен: 0xDeAdBaBeU и 0XdeadBABEu представляют одно и то же число (исключение составляет очень-длинный-суффикс, который имеет вид ll или LL, но никогда lL или Ll)(с C99).

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

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

(с C99)

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

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

int x = 0xE+2;   // error
int y = 0xa+2;   // OK
int z = 0xE +2;  // OK
int q = (0xE)+2; // OK

END_OF_DOCUMENT_MARKER

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

Пример

#include <inttypes.h>
#include <stdio.h>
 
int main(void)
{
    printf("123 = %d\n", 123);
    printf("0123 = %d\n", 0123);
    printf("0x123 = %d\n", 0x123);
    printf("12345678901234567890ull = %llu\n", 12345678901234567890ull);
    // the type is a 64-bit type (unsigned long long or possibly unsigned long)
    // even without a long suffix
    printf("12345678901234567890u = %"PRIu64"\n", 12345678901234567890u );
 
    // printf("%lld\n", -9223372036854775808); // Error:
        // the value 9223372036854775808 cannot fit in signed long long, which
        // is the biggest type allowed for unsuffixed decimal integer constant
 
    printf("%llu\n", -9223372036854775808ull );
    // unary minus applied to unsigned value subtracts it from 2^64,
    // this gives unsigned 9223372036854775808
 
    printf("%lld\n", -9223372036854775807ll - 1);
    // correct way to form signed value -9223372036854775808
}

Вывод:

123 = 123
0123 = 83
0x123 = 291
12345678901234567890ull = 12345678901234567890
12345678901234567890u = 12345678901234567890
9223372036854775808
-9223372036854775808

Ссылки

Стандарт C23 (ISO/IEC 9899:2023):

6.4.4.1 Целочисленные константы (с. 57-60)

Стандарт C17 (ISO/IEC 9899:2018):

6.4.4.1 Целочисленные константы (с. 45-46)

Стандарт C11 (ISO/IEC 9899:2011):

6.4.4.1 Целочисленные константы (с. 62-64)

Стандарт C99 (ISO/IEC 9899:1999):

6.4.4.1 Целочисленные константы (с. 54-56)

Стандарт C89/C90 (ISO/IEC 9899:1990):

3.1.3.2 Целочисленные константы

См. также

Документация C++ для Целочисленной литералы

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/w/c/language/integer_constant