Oo... adding a coherent character sequence to begin octal-literals

Revision History

Since P0085R3

• Add new section to highlight non-impact on standard library
• Add SG22 poll outcomes
• Rebase Technical Specification onto N5054
• Minor wording improvements

Since P0085R2

• Replace broken unicode character with accent
• Update Wikipedia quote
• Fix octal value of none in Table 149 specification
• Do not look at std::format in this paper
• Wording changes

Since P0085R1

• Fix mismatch in technical specification of integer literals and lexical conventions
• Extend examples with common traps where octal-literals are assumed to be decimals by the programmer
• Extend effects on existing code
• Fix encoding of '

Since P0085R0

• Rebase Technical Specification onto N5008
• Align grammar with C's N3353
• Propose deprecation of original octal literal
• Remove proposed change "Technical Specification C run time library functions: strtol, scanf". This has been handled by C in N3353.
• Remove proposed change to Addendum, character literals. Octals in escape sequences have been added by P2290R3
• Add open question on std::format with the # option for octal literals

Proposal

Proposal to add 0o and 0O as an alternative (and preferred) sequence to introduce octal-literals and deprecate use of the old prefix 0 for non-zero octal-literals.

The syntax rule to interpret integer literals starting with a zero as octal-literals might be called a 'historical mistake'. It can be easily misunderstood by novice programmers and can lead to surprising errors.

To allow future generations (of developers if not compilers) to correct this feature, we propose to add the character sequence 0o and 0O as preferred sequences to introduce an octal-literal. The prefix 0o follows the model set by the prefix 0x to introduce a hex-literal, and (since c++14) 0b to introduce a binary-literal.

Additionally, we propose to deprecate the use of octal integer literals with the 0 prefix, apart from 0 itself; this is similar to C declaring the use of nonzero octal integer literals without the prefix 0o or 0O an obsolescent feature (see 6.11.5 in C2y draft). This opens the door for compilers to warn about the use of the deprecated 0 prefix, and eventually (on the scale of a few releases), potentially interpret numbers with leading zeroes as decimals.

From http://en.wikipedia.org/wiki/Octal//en.wikipedia.org/wiki/Octal: "Newer languages have been abandoning the prefix 0, as decimal numbers are often represented with leading zeroes. The prefix q was introduced to avoid the prefix o being mistaken for a zero, while the prefix 0o was introduced to avoid starting a numerical literal with an alphabetic character (like o or q), since these might cause the literal to be confused with a variable name. The prefix 0o also follows the model set by the prefix 0x used for hexadecimal literals in the C language; it is supported by Haskell,[19] OCaml,[20] Python as of version 3.0,[21] Raku,[22] Ruby,[23] Tcl as of version 9,[24] PHP as of version 8.1,[25] Rust[26] and ECMAScript as of ECMAScript 6[27] (the prefix 0 originally stood for base 8 in JavaScript but could cause confusion,[28] therefore it has been discouraged in ECMAScript 3 and dropped in ECMAScript 5[29])."

This proposal now reflects a recent corresponding change in C (N3353) that was triggered by an earlier version of this proposal.

Examples

Padding

Padding leading zeros are often (attempted to be) used to nicely align numbers. This leads to surprising results if the programmer expected the number to be interpreted as a decimal. For example:

• Table of numbers:

        std::array<std::array<int, 2>, 2> table = {
          { 100, 042 },
          { 107, 000 }
        };

  In this case, the programmer intended to write the decimal numbers 100, 42, 107, and 0. However, the values 000 and 042 are interpreted as octal-literals. While the octal-literal 000 is equivalent to the intended decimal number 0, the octal-literal 042 is equivalent to the decimal number 34, triggering bugs that are hard to find by the octal-unaware programmer or reader of code.

• Examples for issued caused by padding version numbers:

  • https://github.com/AcademySoftwareFoundation/OpenColorIO/issues/1818
  • https://github.com/ThePhD/sol2/issues/265

After this proposal

Following this proposal, these literals all specify the same number:

The old octal literal 052 will remain valid but deprecated.

Effects on standard library

This proposal does not modify the standard library to support the new octal-literal prefix for parsing or output and leaves these changes to a future proposal. SG22 saw P0085R3 during the 2026-04-24 telecon and gave the following feedback (see minutes):

POLL: P0085R3: We recommend against inclusion in C++29 unless the corresponding C++ standard library changes to support 0o (e.g. strtol) are made.

Outcome: Consensus against

For parsing, it was observed that std::basic_istream is defined in terms of std::num_get, which is defined in terms of std::strto* functions. Similarly, std::from_chars also relies on std::strto*. The std::strto* functions are modifed in C by N3353 to support the new octal-literal prefix, so C++ will support the new octal-literal prefix for parsing once the C++ standard rebases onto C2y and some minor edits are made in the specification (e.g., add o to the set of legal characters).

For output, changes are needed in the specification of std::format or std::basic_ostream (defined by std::num_put and std::printf) to produce the new octal-literal prefix.

Effects on existing code

This proposal introduces 0o and 0O as new prefixes for octal-literals. Under the current standard, any sequence starting with 0o or 0O is illegal. Consequently, the proposed additions 0o and 0O will not break existing code.

Additionally, this proposal deprecates the existing error-prone syntax rule for octal-literals starting with a zero, following the example of C (N3353). This would affect existing, traditional octal-literals (i.e. with a leading 0), for instance when defining POSIX file permissions (sometimes padded with multiple leading zeros), as seen in popular repositories (>500 stars) e.g., ROOT, Qt Creator, node-android, KDiff3. We emphasize that we deprecate all octal-literals with a leading 0 except for the literal 0 itself. SG22 saw P0085R3 during the 2026-04-24 telecon and gave the following feedback (see minutes):

POLL: P0085R3: We recommend deprecating multi-digit 00.. literals in C as well.

Outcome: Consensus in favor

We have received concerns that this deprecation leads to warnings for octal-literals that have the same value whether interpreted as octal or decimal. Examples of such literals are: 01, 02, 03, 04, 05, 06, 07. To keep the door open for a future proposal introducing 01...09 as decimal literals (typical use case: 1970y/January/01d), implementations might choose to not diagnose 01..07.

Technical Specification

To match N3353, make the following edits (relative to N5054), highlighting the insertions and removals:

15.12 Predefined macro names [cpp.predefined]

Add the following macro to Table 22 -- Feature-Test Macros [tab:cpp.predefined.ft]:

    __cpp_0o_octals 2026XXL
  

5.13.2 Integer literals [lex.icon]

    octal-literal:
      0
      octal-literal 'opt octal-digit
      prefixed-octal-literal
      unprefixed-octal-literal
    unprefixed-octal-literal:
      0
      0 'opt octal-digit-sequence
    prefixed-octal-literal:
      octal-prefix octal-digit-sequence
  

Before hexadecimal-prefix insert

    octal-prefix: one of
      0o 0O
  

Before hexadecimal-digit-sequence insert

    octal-digit-sequence:
      octal-digit
      octal-digit-sequence 'opt octal-digit
  

Under paragraph 2, replace the text:

2 The hexadecimal-digits a through f and A through F have decimal values ten through fifteen.

[Example 1: The number twelve can be written 12, 014, 0o14, 0XC, or 0b1100. The integer-literals 1048576, 1'048'576, 0X100000, 0x10'0000, and 0'004'000'000 0o0'004'000'000, all have the same value. -- end example]

After paragraph 4, add the paragraph:

An unprefixed-octal-literal that is not 0 is deprecated ([depr.oct]).

31.12.8.4 Enum class perm [fs.enum.perms]

Table 151 -- Enum class perms [tab:fs.enum.perms]

Annex D (normative) Compatibility features [depr]

Add a new section immediately after [depr.lit]:

D??. Deprecated unprefixed octal literal [depr.oct]

1 An unprefixed-octal-literal ([lex.icon]) of the form

      0 'opt octal-digit-sequence 

[Note 1: Use of an unprefixed-octal-literal, except the literal 0, is deprecated because they are often confused with decimals. --end note]

[Example 1:

      int zero = 0;                     // OK
      int more_zeroes = 000;            // deprecated
      int unprefixed_octal = 042;       // deprecated
      int prefixed_octal = 0o42;        // OK
    

--end example]

Acknowledgements

Thanks to Erich Keane, Thomas Köppe, and Jens Maurer for reviewing the draft. The document style was borrowed from Doc. no. N4340