Why was the space character not chosen for C++14 digit separators?

by

There is a previous paper, n3499, which tell us that although Bjarne himself suggested spaces as separators:

While this approach is consistent with one common typeographic style, it suffers from some compatibility problems.

  • It does not match the syntax for a pp-number, and would minimally require extending that syntax.
  • More importantly, there would be some syntactic ambiguity when a hexadecimal digit in the range [a-f] follows a space. The preprocessor would not know whether to perform symbol substitution starting after the space.
  • It would likely make editing tools that grab “words” less reliable.

I guess the following example is the main problem noted:

const int x = 0x123 a;

though in my opinion this rationale is fairly weak. I still can’t think of a real-world example to break it.

The “editing tools” rationale is even worse, since 1'234 breaks basically every syntax highlighter known to mankind (e.g. that used by Markdown in the above question itself!) and makes updated versions of said highlighters much harder to implement.

Still, for better or worse, this is the rationale that led to the adoption of apostrophes instead.

More Related Contents:

  1. Has C++ standard changed with respect to the use of indeterminate values and undefined behavior in C++14?
  2. Is it a conforming compiler extension to treat non-constexpr standard library functions as constexpr?
  3. static_assert dependent on non-type template parameter (different behavior on gcc and clang)
  4. Is a pointer with the right address and type still always a valid pointer since C++17?
  5. Deleted default constructor. Objects can still be created… sometimes
  6. Understanding the example on lvalue-to-rvalue conversion
  7. Self-initialization of a static constexpr variable, is it well-formed?
  8. Are notes and examples in the core language specification of the C++ Standard non-normative?
  9. Why isn’t `std::initializer_list` defined as a literal type?
  10. Classes with both template and non-template conversion operators in the condition of switch statement
  11. Why is `make_unique` disallowed?
  12. Injected class name compiler discrepancy
  13. What changes to C++ made copy initialization work for class with explicit constructor?
  14. Directly write into char* buffer of std::string
  15. How to implement classic sorting algorithms in modern C++?
  16. What happens if you static_cast invalid value to enum class?
  17. What are some uses of decltype(auto)?
  18. What exactly is the “immediate context” mentioned in the C++11 Standard for which SFINAE applies?
  19. Is it legal to compare dangling pointers?
  20. Does a declaration using “auto” match an extern declaration that uses a concrete type specifier?
  21. Is #pragma once part of the C++11 standard?
  22. When do extra parentheses have an effect, other than on operator precedence?
  23. What is the difference between C++03 `throw()` specifier and C++11 `noexcept`?
  24. Familiar template syntax for generic lambdas
  25. Legal to overwrite std::string’s null terminator?
  26. How can I use C++14 features when building qmake projects?
  27. What is the difference between std::quick_exit and std::abort and why was std::quick_exit needed?
  28. Using std::bind with member function, use object pointer or not for this argument?
  29. Why don’t I need to specify “typename” before a dependent type in C++20?
  30. memcpy/memmove to a union member, does this set the ‘active’ member?

Leave a Comment