Custom Types and User-Defined Literals

Yes, user-defined literals can indeed be used with custom types in C++. This allows us to create more expressive and meaningful code. Let's see how this works with an example.

Suppose we have a Distance class that we want to use with user-defined literals to represent various units of distance. Here's a simple implementation:

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
19Distance operator""_kilometers(long double val) {
20  return Distance{static_cast<float>(val * 1000)};
21}
22
23Distance operator""_miles(long double val) {
24  return Distance{static_cast<float>(
25    val * 1609.34
26  )};
27}
28
29int main() {
30  Distance d1 = 5.0_kilometers;
31  Distance d2 = 2.5_miles;
32
33  std::cout << d1;
34  std::cout << d2;
35}

15000 meters
24023.35 meters

In this example, we've defined three user-defined literals: _meters, _kilometers, and _miles. Each of these literals converts a numeric value to a Distance object.

Here's a breakdown of what happens:

• 5.0_kilometers calls the operator""_kilometers function, which returns a Distance object with the value converted to meters.
• 2.5_miles calls the operator""_miles function, similarly converting the value to meters.

The std::ostream& operator<< overload allows us to print Distance objects directly using std::cout.

Using user-defined literals with custom types like this enhances code readability and makes it clear what units are being used, reducing the chance for errors and making the code more maintainable.