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

Is the C language outdated? Some propose radical changes, like removing union and goto. But these features aren't flaws; they're powerful tools when used correctly. Let's explore why these features are essential and how you can use them effectively.

Why the Push Against union and goto?

New attempts to create "safer" C dialects have emerged, one in particular removes both union and goto claiming they are unsafe. Some developers argue they're relics of a bygone era, prone to misuse and sources of bugs. But removing powerful tools limits what developers can achieve. Understanding their purpose is crucial.

union: More Than Just Shared Memory

A union is a special type of construct that allows several different variables to share the same memory location. Think of it as a container that can hold different types of data, but only one at a time. The size of the union is determined by its largest member.

How union Saves Memory

Unlike structs, union avoid padding, potentially saving memory. Consider these examples showcasing the size differences:

struct IntOrFloatOrBool {
 int n; // 4 bytes
 float f; // 4 bytes
 bool b; // 1 byte
};
// [ i i i i ] [ f f f f ] [ b _ _ _ ]
// stored in memory with 12 bytes!

union IntOrFloatOrBool {
 int n; // 4 bytes
 float f; // 4 bytes
 bool b; // 1 byte
};
// [ x x x x ]
// stored in memory with 4 bytes.

Tagged Unions: Bringing Type Safety to union

The real power of union shines when combined with a "tag." A tagged union (also known as a variant) uses an additional field (usually an enum) to indicate which type is currently stored in the union. This makes union type-safe, preventing you from accidentally misinterpreting the data.

Tagged unions have use cases like:

• The Result<T, E> type, enables "errors as values" which is easier to deal with than exceptions.
• The Option<T> type, encapsulates null values.
• Lexical tokens, which support leaner parsers that allow for compile-time type-checks on your Token variants

enum RotateType {
 FULL,
 ANGLE,
};

union _Rotate {
 int rotations;
 float angle;
};

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

Macros: Leveling Up Tagged union Usability

C's verbosity can make tagged unions cumbersome. Function macros offer a solution. You can define macros that handle the construction of tagged unions, improving code readability.

#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);

Unleashing Generics with Macros and Tagged union

Macros also let you (sort of) work with generics, by utilizing its preprocessed text concatenation using double hashtags ##. Here's an implementation of the generic Result<T,E> type as found in languages like Rust.

enum ResultVariant { RESULT_OK, RESULT_ERR};
// the Error type to be used for all Results.
struct Error {
 unsigned int code;
 const char * message;
};
// a macro for creating a Result implementation for some arbitrary type T =====
#define deriveResult(T) \
union _Result_##T { \
struct Error err; \
int ok; \
}; \
struct Result_##T { \
enum ResultVariant type; \
union _Result_##T unwrap; \
};

goto: When Unstructured Can Be Good

goto gets a bad rap, often associated with spaghetti code. However, used judiciously, goto can enhance readability and simplify error handling. The key is to ensure it improves code clarity, not obscures it.

goto for Resource Cleanup

A common and accepted use case for goto is for centralizing resource cleanup in a function. This avoids code duplication and makes it easier to manage resources, for example, in the Linux kernel.

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;
}

The Context Matters

The "goto statement considered harmful" argument needs context. When goto obscures program flow, it's harmful. But when it clarifies it, it's a valuable tool. Judge each use case individually.

Mastering C: It's About Understanding, Not Restriction

The true "warts" of C lie elsewhere such as lack of namespaces, lack of a dedicated build system, and a substandard standard library (i.e. gets). union and goto are not flaws. They empower developers to solve problems ingeniously. Don't blindly follow dogmatic rules. Understand the tools, and use them wisely.

Level Up Your C Skills

Embrace the power of union for memory optimization and type-safe polymorphism. Master goto for streamlined error handling and clearer code flow. By understanding these features, you'll unlock new levels of control and efficiency in your C programming projects.