Allows values of integer type to be used in expressions directly.
An integer literal has the form.
decimalliteral integersuffix(optional)  (1)  
octalliteral integersuffix(optional)  (2)  
hexliteral integersuffix(optional)  (3)  
binaryliteral integersuffix(optional)  (4)  (since C++14) 
where.
1
, 2
, 3
, 4
, 5
, 6
, 7
, 8
, 9
), followed by zero or more decimal digits (0
, 1
, 2
, 3
, 4
, 5
, 6
, 7
, 8
, 9
) 0
) followed by zero or more octal digits (0
, 1
, 2
, 3
, 4
, 5
, 6
, 7
) 0x
or the character sequence 0X
followed by one or more hexadecimal digits (0
, 1
, 2
, 3
, 4
, 5
, 6
, 7
, 8
, 9
, a
, A
, b
, B
, c
, C
, d
, D
, e
, E
, f
, F
) 0b
or the character sequence 0B
followed by one or more binary digits (0
, 1
) u
or the character U
) l
or the character L
)
 (since C++11) 
 (since C++23) 
Optional single quotes (  (since C++14) 
An integer literal (as any literal) is a primary expression.
The first digit of an integer literal is the most significant.
Example. The following variables are initialized to the same value:
int d = 42; int o = 052; int x = 0x2a; int X = 0X2A; int b = 0b101010; // C++14
Example. The following variables are also initialized to the same value:
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
The type of the integer literal is the first type in which the value can fit, from the list of types which depends on which numeric base and which integersuffix was used:
Suffix  Decimal bases  Binary, octal, or hexadecimal bases 

(no suffix) 


u or U 


l or L 


both l /L and u /U 


ll or LL 


both ll /LL and u /U 


z or Z 


both z /Z and u /U 


If the value of the integer literal is too big to fit in any of the types allowed by suffix/base combination and the compiler supports extended integer types (such as __int128
) the literal may be given the extended integer type — otherwise the program is illformed.
Letters in the integer literals are caseinsensitive: 0xDeAdBeEfU
and 0XdeadBEEFu
represent the same number (one exception is the longlongsuffix, which is either ll
or LL
, never lL
or Ll
) (since C++11).
There are no negative integer literals. Expressions such as 1
apply the unary minus operator to the value represented by the literal, which may involve implicit type conversions.
In C prior to C99 (but not in C++), unsuffixed decimal values that do not fit in long int
are allowed to have the type unsigned long int
.
When used in a controlling expression of #if or #elif, all signed integer constants act as if they have type  (since C++11) 
Due to maximal munch, hexadecimal integer literals ending in e
and E
, when followed by the operators +
or 
, must be separated from the operator with whitespace or parentheses in the source:
auto x = 0xE+2.0; // error auto y = 0xa+2.0; // OK auto z = 0xE +2.0; // OK auto q = (0xE)+2.0; // OK
Otherwise, a single invalid preprocessing number token is formed, which causes further analysis to fail.
#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 }
Output:
123 83 291 2 12345678901234567890 12345678901234567890 9223372036854775808 9223372036854775808
userdefined literals(C++11)  literals with userdefined suffix 
C documentation for integer constant 
© cppreference.com
Licensed under the Creative Commons AttributionShareAlike Unported License v3.0.
https://en.cppreference.com/w/cpp/language/integer_literal