# Integer literal

> C++ Atlas: `cppatlas.com/w/cpp/language/integer_literal` | Source: https://en.cppreference.com/w/cpp/language/integer_literal | Domain: Language | Standards: C++11, C++14, C++23

Allows values of integer type to be used in expressions directly.

## Official Specification Summary (cppreference)

Allows values of integer type to be used in expressions directly.

### Syntax

An integer literal has the form

- *decimal-literal* *integer-suffix* (optional)    (1)
- *octal-literal* *integer-suffix* (optional)    (2)
- *hex-literal* *integer-suffix* (optional)    (3)
- *binary-literal* *integer-suffix* (optional)    (4) (since C++14)

where

- *decimal-literal* is a non-zero 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`)
- *octal-literal* is the digit zero (`0`) followed by zero or more octal digits (`0`, `1`, `2`, `3`, `4`, `5`, `6`, `7`)
- *hex-literal* is the character sequence `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`)
- *binary-literal* is the character sequence `0b` or the character sequence `0B` followed by one or more binary digits (`0`, `1`)
- *integer-suffix*, if provided, may contain one or both of the following (if both are provided, they may appear in any order:

  - *unsigned-suffix* (the character `u` or the character `U`)
  - one of

  - *long-suffix* (the character `l` or the character `L`)

  - *long-long-suffix* (the character sequence `ll` or the character sequence `LL`) (since C++11)

  - *size-suffix* (the character `z` or the character `Z`) (since C++23)

Optional single quotes (`'`) may be inserted between the digits as a separator; they are ignored when determining the value of the literal. (since C++14)

An integer literal (as any literal) is a primary expression.

### Explanation

1) Decimal integer literal (base 10).

2) Octal integer literal (base 8).

3) Hexadecimal integer literal (base 16, the letters `'a'` through `'f'` represent values (decimal) 10 through 15).

4) Binary integer literal (base 2).

The first digit of an integer literal is the most significant.

Example. The following variables are initialized to the same value:

```cpp
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:

```cpp
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 literal

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 *integer-suffix* was used:

| Suffix | Decimal bases | Binary, octal, or hexadecimal bases |
| --- | --- | --- |
| (no suffix) | - `int` - `long int` - `long long int` (since C++11) | - `int` - `unsigned int` - `long int` - `unsigned long int` - `long long int` (since C++11) - `unsigned long long int` (since C++11) |
| `u` or `U` | - `unsigned int` - `unsigned long int` - `unsigned long long int` (since C++11) | - `unsigned int` - `unsigned long int` - `unsigned long long int` (since C++11) |
| `l` or `L` | - `long int` - `unsigned long int` (until C++11) - `long long int` (since C++11) | - `long int` - `unsigned long int` - `long long int` (since C++11) - `unsigned long long int` (since C++11) |
| both `l`/`L` and `u`/`U` | - `unsigned long int` - `unsigned long long int` (since C++11) | - `unsigned long int` - `unsigned long long int` (since C++11) |
| `ll` or `LL` | - `long long int` (since C++11) | - `long long int` (since C++11) - `unsigned long long int` (since C++11) |
| both `ll`/`LL` and `u`/`U` | - `unsigned long long int` (since C++11) | - `unsigned long long int` (since C++11) |
| `z` or `Z` | - the signed version of `std::size_t` (since C++23) | - the signed version of `std::size_t` (since C++23) - `std::size_t` (since C++23) |
| both `z`/`Z` and `u`/`U` | - `std::size_t` (since C++23) | - `std::size_t` (since C++23) |

If the value of the integer literal that does not have *size-suffix* (since C++23) is too big to fit in any of the types allowed by suffix/base combination and the compiler supports an extended integer type (such as `__int128`) which can represent the value of the literal, the literal may be given that extended integer type — otherwise the program is ill-formed.

### Notes

Letters in the integer literals are case-insensitive: `0xDeAdBeEfU` and `0XdeadBEEFu` represent the same number (one exception is the *long-long-suffix*, 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 `std::intmax_t` and all unsigned integer constants act as if they have type `std::uintmax_t`. (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:

```cpp
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.

| Feature-test macro | Value | Std | Feature |
| --- | --- | --- | --- |
| `__cpp_binary_literals` | `201304L` | (C++14) | Binary literals |
| `__cpp_size_t_suffix` | `202011L` | (C++23) | Literal suffixes for `std::size_t` and its signed version |

### Example

```cpp
#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:

```text
123
83
291
2
12345678901234567890
12345678901234567890
9223372036854775808
-9223372036854775808
```

### Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

| DR | Applied to | Behavior as published | Correct behavior |
| --- | --- | --- | --- |
| CWG 2698 | C++23 | an integer literal with *size-suffix* could have an extended integer type | ill-formed if too large |

### References

- C++23 standard (ISO/IEC 14882:2024):

  - 5.13.2 Integer literals [lex.icon]

- C++20 standard (ISO/IEC 14882:2020):

  - 5.13.2 Integer literals [lex.icon]

- C++17 standard (ISO/IEC 14882:2017):

  - 5.13.2 Integer literals [lex.icon]

- C++14 standard (ISO/IEC 14882:2014):

  - 2.14.2 Integer literals [lex.icon]

- C++11 standard (ISO/IEC 14882:2011):

  - 2.14.2 Integer literals [lex.icon]

- C++98 standard (ISO/IEC 14882:1998):

  - 2.13.1 Integer literals [lex.icon]

### See also

- [user-defined literals (C++11)](https://en.cppreference.com/w/cpp/language/user_literal): literals with user-defined suffix
- [C documentation for integer constant](https://en.cppreference.com/w/c/language/integer_constant)

---
Attribution: content from https://en.cppreference.com/w/cpp/language/integer_literal (cppreference.com), licensed under CC-BY-SA 3.0 and GFDL. Modified: converted to markdown, study notes added. Offline snapshot of 9 February 2025.