# C Integer Constants

An integer constant is a decimal (base 10), octal (base 8), or hexadecimal (base 16) number that represents an integral value. Use integer constants to represent integer values that can't be changed.

## Syntax

`integer-constant`:
`decimal-constant` `integer-suffix`opt
`octal-constant` `integer-suffix`opt
`hexadecimal-constant` `integer-suffix`opt

`decimal-constant`:
`nonzero-digit`
`decimal-constant` `digit`

`octal-constant`:
`0`
`octal-constant` `octal-digit`

`hexadecimal-constant`:
`hexadecimal-prefix` `hexadecimal-digit`
`hexadecimal-constant` `hexadecimal-digit`

`hexadecimal-prefix`: one of
`0x` `0X`

`nonzero-digit`: one of
`1 2 3 4 5 6 7 8 9`

`octal-digit`: one of
`0 1 2 3 4 5 6 7`

`hexadecimal-digit`: one of
`0 1 2 3 4 5 6 7 8 9`
`a b c d e f`
`A B C D E F`

`integer-suffix`:
`unsigned-suffix` `long-suffix`opt
`unsigned-suffix` `long-long-suffix`
`unsigned-suffix` `64-bit-integer-suffix`
`long-suffix` `unsigned-suffix`opt
`long-long-suffix` `unsigned-suffix`opt
`64-bit-integer-suffix`

`unsigned-suffix`: one of
`u U`

`long-suffix`: one of
`l L`

`long-long-suffix`: one of
`ll LL`

`64-bit-integer-suffix`: one of
`i64 I64`

The `i64` and `I64` suffixes are Microsoft-specific.

Integer constants are positive unless they're preceded by a minus sign (`-`). The minus sign is interpreted as the unary arithmetic negation operator. (See Unary Arithmetic Operators for information about this operator.)

If an integer constant begins with `0x` or `0X`, it's hexadecimal. If it begins with the digit `0`, it's octal. Otherwise, it's assumed to be decimal.

The following integer constants are equivalent:

``````28
0x1C   /* = Hexadecimal representation for decimal 28 */
034    /* = Octal representation for decimal 28 */
``````

No white-space characters can separate the digits of an integer constant. These examples show some valid decimal, octal, and hexadecimal constants.

``````    /* Decimal Constants */
int                 dec_int    = 28;
unsigned            dec_uint   = 4000000024u;
long                dec_long   = 2000000022l;
unsigned long       dec_ulong  = 4000000000ul;
long long           dec_llong  = 9000000000LL;
unsigned long long  dec_ullong = 900000000001ull;
__int64             dec_i64    = 9000000000002I64;
unsigned __int64    dec_ui64   = 90000000000004ui64;

/* Octal Constants */
int                 oct_int    = 024;
unsigned            oct_uint   = 04000000024u;
long                oct_long   = 02000000022l;
unsigned long       oct_ulong  = 04000000000UL;
long long           oct_llong  = 044000000000000ll;
unsigned long long  oct_ullong = 044400000000000001Ull;
__int64             oct_i64    = 04444000000000000002i64;
unsigned __int64    oct_ui64   = 04444000000000000004uI64;