Chapter 21 - Enums

Enums (short for enumerations) are a powerful feature in many programming languages. They allow developers to define a set of named values that represent discrete options within a category. Enums are particularly useful when you want to work with a group of related constants in a type-safe and readable way. In this article, we will explore what enums are, how they work, and how you can use them effectively in various programming languages.

What Exactly Are Enums?

Enums are user-defined data types that consist of a set of named constants, which are also called enumerators. Each enumerator represents a fixed value, making enums ideal for scenarios where you need a limited number of predefined options. For example, days of the week, directions, or states in a process can be effectively represented as enums.

Enums can be broadly categorized into two types:

Basic Enums: These are enums where each enumerator is a named constant with an implicit integer value, starting from 0 unless explicitly specified.
Parameterized Enums: These enums allow each enumerator to hold additional data, making them more flexible and expressive.

Key Benefits of Using Enums

Readability: Enums make your code more readable by replacing magic numbers or string literals with meaningful names.
Type Safety: Enums ensure that only valid values are used in your code, reducing runtime errors.
Maintainability: If you need to add or modify values, enums provide a single point of change.
Grouping of Constants: Enums group related constants together, making your codebase more organized.

How Enums Work in Different Programming Languages

Let’s look at how enums are implemented and used in various programming languages.

Enums in Python

Python introduced enums in version 3.4 via the enum module. Here’s how you can define and use basic enums:

from enum import Enum

class Color(Enum):
    RED = 1
    GREEN = 2
    BLUE = 3

# Accessing enum members
print(Color.RED)         # Output: Color.RED
print(Color.RED.value)   # Output: 1

# Iterating through enum members
for color in Color:
    print(color)

Python also supports parameterized enums using the auto() function and custom attributes:

from enum import Enum, auto

class Status(Enum):
    NEW = auto()
    IN_PROGRESS = auto()
    COMPLETED = auto()

print(Status.NEW.value)  # Output: 1 (auto assigns consecutive integers)

Enums in PHP

Enums were introduced in PHP 8.1 as a native feature. Here’s an example of defining and using enums in PHP:

enum Status: string {
    case NEW = 'new';
    case IN_PROGRESS = 'in_progress';
    case COMPLETED = 'completed';
}

// Accessing enum cases
$status = Status::NEW;

// Using enum cases in a switch
switch ($status) {
    case Status::NEW:
        echo "The task is new.";
        break;
    case Status::IN_PROGRESS:
        echo "The task is in progress.";
        break;
}

Enums in Go

Go does not have a native enum type, but you can achieve similar functionality using constants and iota:

package main

import "fmt"

type Status int

const (
    New Status = iota
    InProgress
    Completed
)

func main() {
    fmt.Println(New)         // Output: 0
    fmt.Println(InProgress)  // Output: 1
    fmt.Println(Completed)   // Output: 2
}

Enums in C++

C++ supports enums in two forms: traditional enums and enum classes.

Traditional Enums

#include <iostream>

enum Color {
    RED,
    GREEN,
    BLUE
};

int main() {
    Color color = RED;
    std::cout << color << std::endl;  // Output: 0
    return 0;
}

Enum Classes

Enum classes are strongly typed and scoped:

#include <iostream>

enum class Color {
    RED,
    GREEN,
    BLUE
};

int main() {
    Color color = Color::RED;
    // std::cout << color;  // Error: need explicit conversion
    std::cout << static_cast<int>(color) << std::endl;  // Output: 0
    return 0;
}

Enums in Zig

In Zig, enums are versatile and can include associated values:

const std = @import("std");

const Status = enum {
    New,
    InProgress,
    Completed,
};

pub fn main() !void {
    var status = Status.New;
    std.debug.print("Status: {\n}", .{status});
}

Enums in Zig can also have associated data:

const std = @import("std");

const Status = enum {
    New,
    InProgress,
    Completed,
    Error: u32,
};

pub fn main() !void {
    var status = Status.Error(404);
    std.debug.print("Status: {\n}", .{status});
}

When to Use Enums in Your Code

Enums are ideal in situations where:

You have a fixed set of related constants (e.g., days of the week, directions).
You need to improve the readability of your code by replacing numeric or string literals with descriptive names.
You want to ensure type safety by restricting values to a specific set.

Conclusion: Mastering the Power of Enums

Enums are a foundational feature in many programming languages, offering significant advantages in readability, maintainability, and type safety. By understanding and using enums effectively, you can write cleaner, more robust code. Whether you’re working with basic enums or exploring more advanced parameterized enums, they’re a tool you’ll find indispensable in your programming journey.

Last modified: 26 January 2025