Expanding the Image API

Enum Class vs Regular Enum

Why do we use enum class for ScalingMode instead of a regular enum?

Abstract art representing computer programming

Using enum class for ScalingMode instead of a regular enum is a deliberate choice that offers several advantages. Let's explore why we might prefer enum class in this context:

Type Safety

The primary benefit of enum class is improved type safety. Unlike regular enums, enum classes are strongly typed and don't implicitly convert to integers. This prevents accidental comparisons or assignments with other types.

Consider this example with a regular enum:

1enum ScalingMode { None, Fill, Contain };
2
3void SetScaling(ScalingMode Mode) {
4  // This compiles, but it's probably not
5  // what we meant
6  if (Mode == 1) {
7    // ...
8  }
9}
10
11int main() {
12  // This also compiles, but it's not type-safe
13  SetScaling(2);
14}

Now, let's see how enum class improves this:

1enum class ScalingMode { None, Fill, Contain };
2
3void SetScaling(ScalingMode Mode) {
4  if (Mode == 1) {  
5    // ...
6  }
7}
8
9int main() {
10  SetScaling(2);  
11}

1error: no viable conversion from 'int' to 'ScalingMode'
2error: invalid operands to binary expression ('ScalingMode' and 'int')

Scope

Enum classes introduce a new scope, which helps prevent name clashes. With regular enums, the enum values are in the same scope as the enum, which can lead to naming conflicts:

1enum Color { Red, Green, Blue };
2enum TrafficLight { Red, Yellow, Green };

1error: redefinition of enumerator 'Red'
2error: redefinition of enumerator 'Green'

With enum classes, this isn't an issue:

1enum class Color { Red, Green, Blue };
2// No problem!
3enum class TrafficLight { Red, Yellow, Green };
4
5void SetColor(Color C) {
6  // We must use Color::Red, not just Red
7  if (C == Color::Red) {
8    // ...
9  }
10}

Explicit Conversions

While enum classes don't implicitly convert to integers, you can still perform explicit conversions when needed:

1enum class ScalingMode { None, Fill, Contain };
2
3void PrintScalingMode(ScalingMode Mode) {
4  switch (Mode) {
5    case ScalingMode::None:
6      std::cout << "None ("
7        << static_cast<int>(Mode) << ")\n";
8      break;
9    case ScalingMode::Fill:
10      std::cout << "Fill ("
11        << static_cast<int>(Mode) << ")\n";
12      break;
13    case ScalingMode::Contain:
14      std::cout << "Contain ("
15        << static_cast<int>(Mode) << ")\n";
16      break;
17  }
18}
19
20int main() {
21  PrintScalingMode(ScalingMode::Fill);
22}

1Fill (1)

By using enum class for ScalingMode, we're creating a more robust and self-documenting API for our Image class. It helps prevent errors and makes the code's intent clearer, which is particularly valuable in larger codebases or when working in teams.

This Question is from the Lesson: