Portability of User-Defined Literals

Ensuring the portability of user-defined literals across different compilers is crucial for maintaining cross-platform compatibility in C++ projects. Here are some best practices to follow:

The C++ standard specifies that user-defined literals must start with an underscore (_). Adhering to this rule ensures that your literals are compliant with the standard and are less likely to cause conflicts with future standard library literals.

When defining user-defined literals, use the standard types that the C++ standard supports for literals:

• unsigned long long for integer literals
• long double for floating-point literals
• const char* for string literals
• char for character literals

Here's an example of portable user-defined literals:

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

11500 meters

Some compilers might allow non-standard features or extensions. Avoid using these extensions to maintain portability. Stick to the features defined in the C++ standard.

Regularly test your code on multiple compilers, such as GCC, Clang, and MSVC. This practice helps identify and resolve any portability issues early in the development process.

Wrap your user-defined literals in namespaces to prevent naming conflicts. This practice helps ensure that your literals do not clash with literals from other libraries or future standard library additions.

1#include <iostream>
2
Distance Class|Show
3class Distance {/*...*/};
14
15namespace distance_literals {
16  Distance operator""_meters(long double val) {
17    return Distance{static_cast<float>(val)};
18  }
19}
20
21int main() {
22  using namespace distance_literals;
23  Distance d = 2.0_meters;
24  std::cout << d;
25}

12 meters

By following these practices, you can ensure that your user-defined literals remain portable and maintainable across different compilers and platforms.