Underscore in User-Defined Literals

User-defined literals in C++ must start with an underscore (_) to distinguish them from standard library literals and to ensure future compatibility. Here's why this rule is important:

Differentiation from Standard Literals

The underscore requirement ensures that user-defined literals are distinct from standard literals provided by the C++ standard library. For example, the standard library provides the "s" suffix for std::string literals:

1#include <string>
2using namespace std::string_literals;
3
4std::string str = "Hello"s;

Without the underscore requirement, there could be a conflict between user-defined and standard literals, leading to ambiguity and potential errors in the code.

Future Compatibility

By mandating the underscore, the C++ standard reserves the possibility of adding new standard literals in future versions without breaking existing code.

If user-defined literals could omit the underscore, any new standard literals could conflict with existing user-defined ones, causing significant compatibility issues.

Example

Here's an example demonstrating the use of user-defined literals with an underscore:

1#include <iostream>
2
3class Distance {
4 public:
5  Distance(float value) : value{value} {}
6  float value;
7};
8
9std::ostream& operator<<(
10  std::ostream& os, Distance d) {
11  os << d.value << " meters\n";
12  return os;
13}
14
15Distance operator""_meters(long double val) {
16  return Distance{static_cast<float>(val)};
17}
18
19int main() {
20  Distance d = 5.0_meters;
21  std::cout << d;
22}

15 meters

Standard Enforcement

Most modern compilers enforce this rule, but some older compilers or less compliant ones might not.

Even if your current compiler does not enforce the underscore, it's a good practice to follow the standard for the sake of portability and future-proofing your code.

Conclusion

Using an underscore in user-defined literals is a simple but important rule that helps maintain clear, unambiguous, and future-proof code.

It differentiates your custom literals from those provided by the standard library and ensures compatibility with future updates to the C++ standard.