Integer constant
Allows values of integer type to be used in expressions directly.
Contents 
[edit] Syntax
An integer constant is a nonlvalue expression of the form
decimalconstant integersuffix(optional)  (1)  
octalconstant integersuffix(optional)  (2)  
hexconstant integersuffix(optional)  (3)  
binaryconstant integersuffix(optional)  (4)  (since C23)  
where
 decimalconstant is a nonzero decimal digit (
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
)  octalconstant is the digit zero (
0
) followed by zero or more octal digits (0
,1
,2
,3
,4
,5
,6
,7
)  hexconstant is the character sequence
0x
or the character sequence0X
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
)  binaryconstant is the character sequence
0b
or the character sequence0B
followed by one or more binary digits (0
,1
)  integersuffix, if provided, may contain one or both of the following (if both are provided, they may appear in any order):
 unsignedsuffix (the character
u
or the characterU
)  longsuffix (the character
l
or the characterL
) or the longlongsuffix (the character sequencell
or the character sequenceLL
) (since C99)
 unsignedsuffix (the character
Optional single quotes ( 
(since C23) 
[edit] Explanation
The following variables are initialized to the same value:
int d = 42; int o = 052; int x = 0x2a; int X = 0X2A; int b = 0b101010; // C23
The following variables are also initialized to the same value:
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
[edit] The type of the integer constant
The type of the integer constant 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.
Types allowed for integer constants  

suffix  decimal bases  other bases 
no suffix  int
long int 
int
unsigned int 
u or U

unsigned int
unsigned long int 
unsigned int
unsigned long int 
l or L

long int
unsigned long int(until C99) 
long int
unsigned long int 
both l /L and u /U

unsigned long int
unsigned long long int(since C99) 
unsigned long int
unsigned long long int(since C99) 
ll or LL

long long int(since C99)  long long int(since C99)
unsigned long long int(since C99) 
both ll /LL and u /U

unsigned long long int(since C99)  unsigned long long int(since C99) 
If the value of the integer constant 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 constant may be given the extended integer type; otherwise, the program is illformed.
[edit] Notes
Letters in the integer constants are caseinsensitive: 0xDeAdBaBeU
and 0XdeadBABEu
represent the same number (one exception is the longlongsuffix, which is either ll
or LL
, never lL
or Ll
) (since C99)
There are no negative integer constants. Expressions such as 1 apply the unary minus operator to the value represented by the constant, which may involve implicit type conversions.
When used in a controlling expression of #if or #elif, all signed integer constants act as if they have type intmax_t and all unsigned integer constants act as if they have type uintmax_t. 
(since C99) 
Integer constants may be used in integer constant expressions.
Due to maximal munch, hexadecimal integer constants ending in e
and E
, when followed by the operators +
or 
, must be separated from the operator with whitespace or parentheses in the source:
int x = 0xE+2; // error int y = 0xa+2; // OK int z = 0xE +2; // OK int q = (0xE)+2; // OK
Otherwise, a single invalid preprocessing number token is formed, which causes further analysis to fail.
[edit] Example
#include <stdio.h> #include <inttypes.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 64bit 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", 9223372036854775807ull  1); // correct way to form signed value 9223372036854775808 }
Output:
123 = 123 0123 = 83 0x123 = 291 12345678901234567890ull = 12345678901234567890 12345678901234567890u = 12345678901234567890 9223372036854775808 9223372036854775808
[edit] References
 C17 standard (ISO/IEC 9899:2018):
 6.4.4.1 Integer constants (p: 4546)
 C11 standard (ISO/IEC 9899:2011):
 6.4.4.1 Integer constants (p: 6264)
 C99 standard (ISO/IEC 9899:1999):
 6.4.4.1 Integer constants (p: 5456)
 C89/C90 standard (ISO/IEC 9899:1990):
 3.1.3.2 Integer constants
[edit] See also
C++ documentation for Integer literal
