How can I use type aliases to implement a type-safe enum pattern in C++?

Question

Ryan McCombe · Accepted Answer

Implementing a type-safe enum pattern using type aliases in C++ is an interesting technique that can provide additional type safety and functionality compared to traditional enums.

This pattern is particularly useful when you want to create strongly-typed enumerations with custom behavior. Let's explore how to implement this pattern step by step.

Basic Implementation

Here's a basic implementation of a type-safe enum pattern using type aliases:

1#include <iostream>
2
3class Color {
4 public:
5  class ColorType {
6    friend class Color;
7    ColorType() = default;
8
9   public:
10    bool operator==(const ColorType&) const
11      = default;
12  };
13
14  static const ColorType Red;
15  static const ColorType Green;
16  static const ColorType Blue;
17
18  using Type = const ColorType&;
19
20 private:
21  Type m_value;
22
23 public:
24  constexpr Color(Type value)
25    : m_value(value) {}
26  constexpr operator Type() const {
27    return m_value;
28  }
29};
30
31const Color::ColorType Color::Red{};
32const Color::ColorType Color::Green{};
33const Color::ColorType Color::Blue{};
34
35int main() {
36  Color c = Color::Red;
37
38  if (c == Color::Red) {
39    std::cout << "The color is red!\n";
40  }
41}

1The color is red!

In this implementation:

We define a Color class with a nested ColorType class.
We use using Type = const ColorType&; to create an alias for our enum type.
We define static constant members for each enum value.
The Color class wraps the Type and provides implicit conversion to Type.

Adding Functionality

We can extend this pattern to add functionality to our enum:

1#include <iostream>
2#include <string>
3
4class Color {
5  class ColorType {
6    friend class Color;
7    std::string m_name;
8    explicit ColorType(const std::string& name)
9      : m_name(name) {}
10
11   public:
12    bool operator==(const ColorType&) const
13      = default;
14    const std::string& name() const {
15      return m_name;
16    }
17  };
18
19 public:
20  static const ColorType Red;
21  static const ColorType Green;
22  static const ColorType Blue;
23
24  using Type = const ColorType&;
25
26 private:
27  Type m_value;
28
29 public:
30  constexpr Color(Type value) : m_value(value) {}
31  constexpr operator Type() const {
32    return m_value;
33  }
34  const std::string& name() const {
35    return m_value.name();
36  }
37};
38
39const Color::ColorType Color::Red{"Red"};
40const Color::ColorType Color::Green{"Green"};
41const Color::ColorType Color::Blue{"Blue"};
42
43int main() {
44  Color c = Color::Green;
45
46  std::cout << "The color is " << c.name();
47}

1The color is Green

This version adds a name() method to our enum values, allowing us to get a string representation of each color.

Type Safety Benefits

This pattern provides strong type safety. For example:

1#include <iostream>
2
3class Color {
4  class ColorType {
5    friend class Color;
6    ColorType() = default;
7
8   public:
9    bool operator==(const ColorType&) const
10      = default;
11  };
12
13 public:
14  static const ColorType Red;
15  static const ColorType Green;
16  static const ColorType Blue;
17
18  using Type = const ColorType&;
19
20 private:
21  Type m_value;
22
23 public:
24  constexpr Color(Type value)
25    : m_value(value) {}
26  constexpr operator Type() const {
27    return m_value;
28  }
29};
30
31const Color::ColorType Color::Red{};
32const Color::ColorType Color::Green{};
33const Color::ColorType Color::Blue{};
34
35class Shape {
36 public:
37  class ShapeType {
38    friend class Shape;
39    ShapeType() = default;
40
41   public:
42    bool operator==(const ShapeType&) const
43      = default;
44  };
45
46  static const ShapeType Circle;
47  static const ShapeType Square;
48
49  using Type = const ShapeType&;
50
51 private:
52  Type m_value;
53
54 public:
55  constexpr Shape(Type value)
56    : m_value(value) {}
57  constexpr operator Type() const {
58    return m_value;
59  }
60};
61
62const Shape::ShapeType Shape::Circle{};
63const Shape::ShapeType Shape::Square{};
64
65int main() {
66  Color c = Color::Red;
67  Shape s = Shape::Circle;
68
69  // This will not compile
70  if (c == s) {}
71  
72  // This will not compile either
73  Color wrongColor = Shape::Circle;
74  
75  // But this is fine
76  if (c == Color::Red) {
77    std::cout << "The color is red!";
78  }
79}

1error: binary '==': 'Color' does not define this operator
2error: initializing: cannot convert from 'const Shape::ShapeType' to 'Color'

In this example, we can't compare a Color to a Shape, or assign a Shape value to a Color variable. This level of type safety is not possible with traditional C++ enums.

Conclusion

Using type aliases to implement a type-safe enum pattern in C++ provides several benefits:

Strong type safety: You can't accidentally use one enum type where another is expected.
Extensibility: You can add methods and properties to your enum values.
Encapsulation: The implementation details are hidden within the class.
Flexibility: You can control the underlying type and behavior of your enum.

This pattern is particularly useful in large codebases where type safety is crucial, or when you need enums with custom behavior.

However, it does come with some overhead in terms of code complexity and potential runtime cost compared to traditional enums.

As with any pattern, consider the trade-offs for your specific use case before implementing it.

Type Aliases

Type-Safe Enum Pattern with Aliases

Basic Implementation

Adding Functionality

Type Safety Benefits

Conclusion

Type Aliases

Professional C++

Questions & Answers