Why C's union and goto Deserve Respect: Untangling Misconceptions and Maximizing Potential

Memory safety is a critical concern, and the push toward safer languages is understandable. But throwing out established tools isn't always the answer. While new approaches like TrapC aim to enhance C/C++, some propose radical changes, such as removing union and goto. To say the complete removal of union and goto is outrageous is an understatement. It's harmful and frankly offensive to the language itself.

This article defends these powerful, often misunderstood features, showing how they can be used effectively to write efficient and elegant code. Learn how to leverage union for memory optimization and goto for improved error handling and code clarity.

Why the Fuss About Undefined Behavior in C?

C's performance edge comes from its tolerance of undefined behavior. By offloading safety checks to the programmer, the compiler can perform aggressive optimizations. While this can be annoying, those optimizations are specifically useful for real-time software. Sacrificing those optimizations could lead to unacceptable performance hits.

Unveiling the Power of union in C

For those unfamiliar, unions are a type construct which holds attributes that share the same memory, the alignment of the union being the largest type in it.

Imagine needing to store different data types in the same memory location. That’s where C unions shine. Unlike structs, which allocate memory for each member, unions allow members to share the same memory space. This conserves memory and enables efficient data manipulation.

Consider these examples:

 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.

struct Foo {
 int bar; // 4 bytes
 double baz; // 8 bytes
 bool qux; // 1 byte
};
/*
[ i i i i | _ _ _ _ ]
[ d d d d | d d d d ]
[ b _ _ _ | _ _ _ _ ]
stored in 24 bytes!
(16 if arranged such that double comes first)
*/
union Foo {
 int bar; // 4 bytes
 double baz; // 8 bytes
 bool qux; // 1 byte
};
/*
[ x x x x | x x x x ]
stored in 8 bytes!
*/

Tagged unions: Polymorphism in C

By itself, unions struggle to see any practical application outside of programs that concern themselves with bitwise operations. As it turns out, being able to reinterpret values as other types does offer clever ways of doing bitwise operations. To manage unions effectively, employ the tagged union pattern. This involves combining the union with an enum that indicates the active type.

Tagged unions allow leveraging C for type polymorphism. Here's how to define a tagged union for handling rotations:

 enum RotateType {
 FULL,
 ANGLE,
};
union _Rotate {
 int rotations;
 float angle;
};
typedef struct {
 enum RotateType type;
 union _Rotate unwrap;
} Rotate;

Tagged unions are a type of structure that has a name, a tagged union. The tag here is our extra attribute on our wrapper that determines the union's active type. Tagged unions can be seen in various modern languages, most prominently in Rust (where they are referred to as Enums), Zig, and languages that heavily emphasize pattern matching.

Function Macros: Wizardry for Ergonomic C Code

To create instances of tagged unions, function macros are your friend. Here's how you can define macros for the Rotate type:

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

Now, creating instances becomes much simpler:

Rotate right_angle = Rotate_ANGLE ( 90. 0 f);
Rotate doubleturn = Rotate_FULL ( 2);

goto: Not as Evil as They Say

Edsger Dijkstra's "Goto Statement Considered Harmful" paper is often misinterpreted. goto isn't inherently bad; it's bad when it obscures your program's logic.

goto becomes bad when it obscures our ability to reason about the dynamic nature of our program, and good when it improves it. In fact, it is so useful for handling exit cases of functions that with one quick lookup, you can see that goto is found all over the Linux kernel.

goto for Error Handling and Clean-Up

Consider this snippet from 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;
}

Here, goto streamlines error handling, ensuring resources are released correctly.

Conclusion

C isn't perfect. But instead of removing powerful tools like union and goto, learn to use them effectively. They offer opportunities for clever programmers to create ingenious solutions. Embrace the power and flexibility of C!