Data structures serve as foundational building blocks for modeling real-world entities. In C, a struct aggregates heterogeneous data items under a single identifier, enabling developers to define custom composite types that represent complex objects efficiently.

Declaration Syntax and Memory Layout

The fundamental syntax associates a tag name with a block of member declarations. Instances can be declared immediately alongside the definition or separately.

struct Point {
    float x;
    float y;
} origin; // Immediate declaration creates a global instance named 'origin'

Multiple independent instances require explicit type specification during each declaration:

struct Point p1;
struct Point p2;
struct Point p3;

Members are accessed via the dot operator (.), which establishes a direct path to the internal field within a specific instance.

#include <stdio.h>

struct Device {
    char model[32];
    int serial_number;
    double firmware_version;
};

int main(void) {
    // Aggregate initialization assigns values sequentially
    struct Device router = {"Gateway-X200", 897563, 4.21};

    // Designated initializers allow out-of-order assignment (C99+)
    struct Device printer = {.firmware_version = 2.05, .model = "LaserJet-III", .serial_number = 441002};

    printf("Model: %s | ID: %d | Firmware: %.2f\n", 
           router.model, router.serial_number, router.firmware_version);

    return 0;
}

Internally, a structure occupies contiguous memory. While array indexing uses numeric offsets, struct member access resolves to offset calculations based on the defined layout. String fields must utilize fixed-size character arrays since C lacks built-in dynamic string types.

Type Aliasing with typedef

Prefixing every variable with struct becomes verbose in larger projects. The typedef keyword creates an alias, simplifying instantiation syntax.

typedef struct NetworkConfig {
    unsigned long ip_address;
    unsigned short subnet_mask;
    int max_connections;
} NetConfig;

Once defined, NetConfig behaves identically to struct NetworkConfig:

NetConfig server_conf = {0xC0A80001, 0xFFFFFF00, 256};

Critical Scope Limitation: Aliases created via typedef cannot be referenced inside the defining block due to compilation order constraints. The compiler requires the complete struct TagName identifier for self-referential pointers.

// Valid approach for recursive/self-referential structs
typedef struct TreeNode {
    int value;
    struct TreeNode* left_child;  // Correct: uses explicit tag
} TreeNode;

// Invalid: Compiler does not recognize 'TreeNode' at this scope
// typedef struct TreeNode {
//     int value;
//     TreeNode* right_child; 
// } TreeNode;

Forward declarations resolve this by separating the type alias creation from the internal pointer declaration, ensuring the compiler encounters the full type definition before alias resolution.

Recursive and Multi-Level Composition

Structures can encapsulate other structures, enabling hierarchical data modeling. Initialization follows nested brace notation corresponding to the structural depth.

struct Vector2D {
    float dx;
    float dy;
};

struct BoundingBox {
    struct Vector2D top_left;
    struct Vector2D bottom_right;
    char label[16];
};

int main(void) {
    // Nested aggregate initialization
    struct BoundingBox screen_area = {
        {0.0f, 0.0f},
        {1920.0f, 1080.0f},
        "Primary Monitor"
    };

    // Chain dot operators to traverse levels
    printf("Dimensions: %.0fx%.0f\n", 
           screen_area.bottom_right.dx - screen_area.top_left.dx,
           screen_area.bottom_right.dy - screen_area.top_left.dy);

    return 0;
}

This compositional pattern mirrors relasional database records and is essential for implementing advanced algorithms like linked lists, trees, and serialization protocols. Proper alignment considerations may introduce padding bytes between members to satisfy hardware addressing requirements.