C Structures, Unions & Enums – Organizing Complex Data in C

Introduction – Why Use Structures, Unions & Enums?

In C programming, structures, unions, and enumerations enable developers to group related variables under a single user-defined type. These powerful constructs help model real-world entities, optimize memory usage, and define meaningful constants—leading to more readable, maintainable, and efficient codebases.

In this guide, you’ll learn:

• How to define and use structures, unions, and enums in C
• The differences and advantages of each data grouping mechanism
• Advanced techniques like padding, packing, typedef, and bit fields
• Real-world examples and scenarios where these features are applied

Topics Covered

C Structures

A structure in C allows combining variables of different types into one cohesive unit.

struct Person {
    char name[50];
    int age;
};

This lets you manage multiple related variables like name and age as a single logical block (struct Person).

C Nested & Self-Referential Structures

Nested Structure:

struct Date {
    int day, month, year;
};

struct Event {
    char title[50];
    struct Date eventDate;
};

Self-Referential Structure:

Used for linked lists, trees, and graphs.

struct Node {
    int data;
    struct Node *next;
};

Enables recursive and dynamic data modeling in C.

C Arrays of Structures

Arrays of structures make it easy to manage lists of similar records.

struct Student {
    char name[50];
    int rollNo;
};

struct Student students[100];

Useful in school management systems, inventory lists, etc.

C Structures and Functions

Structures can be passed by value or by reference (pointer).

void printPerson(struct Person p);
void modifyPerson(struct Person *p);

Passing by pointer is more efficient and allows modification.

C Unions

A union shares the same memory space for all its members.

union Data {
    int i;
    float f;
    char str[20];
};

Only one member can be accessed at a time—ideal for memory-saving operations in embedded or protocol-based systems.

C Enumerations (enum)

Enums assign named constants to integers.

enum Color { RED, GREEN, BLUE };

Improves readability and supports meaningful logic control (e.g., switch-case).

C Typedef

Simplifies type declarations:

typedef struct Book {
    char title[50];
    int pages;
} Book;

Instead of struct Book, use just Book.

C Structure Padding and Packing

Padding:

The compiler inserts extra bytes for alignment:

struct Padded {
    char c;
    int i;
};

Packing:

Use pragmas to disable padding:

#pragma pack(1)

Useful in file I/O, communication protocols, and embedded systems.

C Bit Fields

Control the exact number of bits used by a structure member.

struct Flags {
    unsigned int isVisible : 1;
    unsigned int isEnabled : 1;
};

Perfect for memory-constrained systems and binary flags.

C Anonymous Structures and Unions

Structures/unions without a name allow flattened member access.

struct {
    int x, y;
    union {
        int intVal;
        float floatVal;
    };
} point;

Access fields like point.x or point.floatVal directly.

Summary – Key Takeaways

These foundational C constructs empower you to create modular, efficient, and meaningful representations of real-world data in your programs.

Key Concepts Recap:

• struct → groups multiple data types
• union → efficient memory reuse
• enum → readable named constants
• typedef → shorthand for complex types
• Bit fields and packing → memory optimization

Real-World Use Cases:
Used in file parsers, microcontrollers, graphics engines, OS kernels, and network protocol implementations.

Frequently Asked Questions (FAQ)

What is the difference between struct and union?
Struct stores all members separately; union shares memory—only one field valid at a time.

When should I use typedef with struct?
Use it when you want cleaner syntax and shorter code, especially in APIs and libraries.

Why does padding matter in structures?
Padding ensures proper memory alignment. It affects memory usage and performance, especially in embedded and low-level systems.

Are enums just constants?
Yes, but with names. They improve readability and are safer than magic numbers.

What is the use of anonymous structures or unions?
They allow direct access to nested members, ideal for hardware abstraction and reducing verbosity in struct definitions.