Stop the Hate: Why union and goto Still Matter in C Programming

Is C programming losing its edge? Some propose removing union and goto, claiming they're unsafe and outdated. But are these features truly harmful, or are we throwing the baby out with the bathwater? Let's dive into why these often-misunderstood tools are still valuable assets for skilled programmers.

The Memory Safety Debate: Are We Sacrificing Performance for Security?

Memory safety is a hot topic, particularly with government entities pushing for safer coding practices. While rewriting entire codebases in memory-safe languages is daunting, some suggest modifying C/C++ to be safer. But eliminating features like union and goto might be too extreme.

• Performance Hit: C's speed comes from its low-level control and the compiler's ability to optimize based on undefined behavior. Removing this flexibility can significantly impact performance, especially in real-time applications.
• Is it Worth it?: Before we change, we need to know that it is the right choice.

union and goto: Why the Controversy?

Some argue that union and goto are unsafe and should be deprecated. But this view overlooks their potential for improving code readability, reducing duplication, and optimizing memory usage. To arbitrarily can these tools is harmful.

Understanding union: Memory Efficiency and Bitwise Operations

A union is a special type that allows different attributes to share the same memory space. This can lead to significant memory savings, especially when dealing with varied data types.

How union Saves Memory: A Practical Example

Consider a scenario where you need to store an integer, a float, or a boolean value. Using a struct would allocate memory for all three, even if only one is used at a time. But a union only allocates enough memory for the largest type, optimizing memory usage.

struct IntOrFloatOrBool {
    int n;   // 4 bytes
    float f; // 4 bytes
    bool b;  // 1 byte
};
// Stored in memory with 12 bytes!

union IntOrFloatOrBool {
    int n;   // 4 bytes
    float f; // 4 bytes
    bool b;  // 1 byte
};
// Stored in memory with 4 bytes!

Tagged Unions: Adding Type Safety to Unions

To track the active type stored in a union, we can create a tagged union. This involves wrapping the union within a struct that includes an enum to indicate the active type. This method allows for type polymorphism, without resorting to void pointers.

enum RotateType { FULL, ANGLE };

union _Rotate {
    int rotations;
    float angle;
};

typedef struct {
    enum RotateType type;
    union _Rotate unwrap;
} Rotate;

Tagged unions are very useful and prominent in other languages like Rust and Zig.

Function Macros: Improving Tagged Union Ergonomics

Working with tagged unions in C can be verbose. Function macros can simplify the process by creating instances more efficiently.

#define Rotate_FULL(_degrees) \
((Rotate) { .type = FULL, .unwrap = (union _Rotate) { .rotations = (_degrees) }})

#define Rotate_ANGLE(_angle) \
((Rotate) { .type = ANGLE, .unwrap = (union _Rotate) { .angle = (_angle) }})

Rotate right_angle = Rotate_ANGLE(90.0f);
Rotate doubleturn = Rotate_FULL(2);

goto: Controlled Jumps for Clarity and Error Handling

Despite its bad reputation, goto can be incredibly useful for managing complex control flow, especially in error handling and escaping nested loops.

goto in Error Handling: Streamlining Cleanup

In the Linux kernel, goto is frequently used to handle exit cases and ensure proper resource cleanup. By providing a clear and direct path to the cleanup code, goto enhances readability and reduces code duplication.

static int __init button_init(void) {
    int error;
    if (request_irq(BUTTON_IRQ, button_interrupt, 0, "button", NULL)) {
        printk(KERN_ERR "button.c: Can't allocate irq %d\n", button_irq);
        return -EBUSY;
    }
    button_dev = input_allocate_device();
    if (!button_dev) {
        printk(KERN_ERR "button.c: Not enough memory\n");
        error = -ENOMEM;
        goto err_free_irq;
    }
    button_dev->evbit[0] = BIT_MASK(EV_KEY);
    button_dev->keybit[BIT_WORD(BTN_0)] = BIT_MASK(BTN_0);
    error = input_register_device(button_dev);
    if (error) {
        printk(KERN_ERR "button.c: Failed to register device\n");
        goto err_free_dev;
    }
    return 0;

err_free_dev:
    input_free_device(button_dev);
err_free_irq:
    free_irq(BUTTON_IRQ, button_interrupt);
    return error;
}

Conclusion: Embracing C's Versatility

While C has its imperfections, union and goto aren't among them. These features, when used judiciously, empower programmers to create efficient, elegant, and maintainable code. Instead of shying away from these tools, let's embrace their potential and continue to explore the endless possibilities of C programming.