Advanced Structure Concepts

Introduction

Advanced structure concepts in C extend beyond basic structure usage to include sophisticated features like bit fields, structure packing, flexible array members, and self-referential structures. These concepts enable programmers to optimize memory usage, implement complex data structures, and create efficient representations of real-world entities. Understanding these advanced features is essential for systems programming, embedded development, and performance-critical applications.

Bit Fields

Basic Bit Field Declaration

Bit fields allow you to specify the exact number of bits used for structure members, enabling efficient memory usage for small values:

#include <stdio.h>

struct FilePermissions {
    unsigned int read : 1;     // 1 bit
    unsigned int write : 1;    // 1 bit
    unsigned int execute : 1;  // 1 bit
    unsigned int reserved : 5; // 5 bits
};

int main() {
    struct FilePermissions perm;
    
    // Set permissions
    perm.read = 1;
    perm.write = 1;
    perm.execute = 0;
    perm.reserved = 0;
    
    printf("Size of struct: %zu bytes\n", sizeof(perm));
    printf("Read: %d\n", perm.read);
    printf("Write: %d\n", perm.write);
    printf("Execute: %d\n", perm.execute);
    printf("Reserved: %d\n", perm.reserved);
    
    return 0;
}

Practical Bit Field Usage

1. Hardware Register Representation

Bit fields are commonly used to represent hardware registers with specific bit layouts:

#include <stdio.h>
#include <stdint.h>

struct GPIO_Register {
    uint32_t pin0  : 2;  // 2 bits for pin 0 configuration
    uint32_t pin1  : 2;  // 2 bits for pin 1 configuration
    uint32_t pin2  : 2;  // 2 bits for pin 2 configuration
    uint32_t pin3  : 2;  // 2 bits for pin 3 configuration
    uint32_t mode  : 4;  // 4 bits for mode selection
    uint32_t reserved : 20; // Remaining bits reserved
};

int main() {
    struct GPIO_Register gpio = {0};
    
    // Configure pins
    gpio.pin0 = 1;  // Output mode
    gpio.pin1 = 0;  // Input mode
    gpio.pin2 = 1;  // Output mode
    gpio.pin3 = 2;  // Alternate function
    gpio.mode = 5;  // Specific mode
    
    printf("GPIO Register Value: 0x%08X\n", *(uint32_t*)&gpio);
    printf("Pin 0 Configuration: %d\n", gpio.pin0);
    printf("Pin 1 Configuration: %d\n", gpio.pin1);
    printf("Mode: %d\n", gpio.mode);
    
    return 0;
}

2. Network Protocol Headers

Bit fields are useful for implementing network protocol headers with specific bit layouts:

#include <stdio.h>
#include <stdint.h>

struct IP_Header {
    uint32_t version : 4;        // 4 bits
    uint32_t ihl : 4;           // 4 bits
    uint32_t tos : 8;           // 8 bits
    uint32_t total_length : 16; // 16 bits
    uint32_t identification : 16; // 16 bits
    uint32_t flags : 3;         // 3 bits
    uint32_t fragment_offset : 13; // 13 bits
    uint32_t ttl : 8;           // 8 bits
    uint32_t protocol : 8;      // 8 bits
    uint32_t checksum : 16;     // 16 bits
    uint32_t source_ip : 32;    // 32 bits
    uint32_t dest_ip : 32;      // 32 bits
};

int main() {
    struct IP_Header ip_header = {0};
    
    // Set header values
    ip_header.version = 4;           // IPv4
    ip_header.ihl = 5;              // 5 * 4 = 20 bytes
    ip_header.tos = 0;
    ip_header.total_length = 100;
    ip_header.identification = 12345;
    ip_header.flags = 2;            // Don't fragment
    ip_header.fragment_offset = 0;
    ip_header.ttl = 64;
    ip_header.protocol = 6;         // TCP
    ip_header.source_ip = 0xC0A80101; // 192.168.1.1
    ip_header.dest_ip = 0xC0A80102;   // 192.168.1.2
    
    printf("IP Header Size: %zu bytes\n", sizeof(ip_header));
    printf("Version: %d\n", ip_header.version);
    printf("Header Length: %d words\n", ip_header.ihl);
    printf("Total Length: %d bytes\n", ip_header.total_length);
    printf("Protocol: %d\n", ip_header.protocol);
    
    return 0;
}

Bit Field Limitations and Considerations

1. Portability Issues

Bit field layout is implementation-defined and may vary between compilers:

#include <stdio.h>

struct BitFieldExample {
    unsigned int a : 3;
    unsigned int b : 4;
    unsigned int c : 5;
};

int main() {
    struct BitFieldExample bf = {1, 2, 3};
    
    printf("Size: %zu bytes\n", sizeof(bf));
    printf("Values: a=%d, b=%d, c=%d\n", bf.a, bf.b, bf.c);
    
    // Bit layout is implementation-defined
    unsigned int *ptr = (unsigned int*)&bf;
    printf("Raw value: 0x%08X\n", *ptr);
    
    return 0;
}

2. Alignment and Padding

Bit fields may introduce padding for alignment:

#include <stdio.h>

struct PackedBits {
    unsigned int a : 1;
    unsigned int b : 1;
    unsigned int c : 1;
};

struct AlignedStruct {
    char x;
    struct PackedBits bits;
    char y;
};

int main() {
    printf("Size of PackedBits: %zu bytes\n", sizeof(struct PackedBits));
    printf("Size of AlignedStruct: %zu bytes\n", sizeof(struct AlignedStruct));
    
    return 0;
}

Structure Packing and Alignment

Default Structure Alignment

Compilers add padding to structures to ensure proper alignment:

#include <stdio.h>

struct Unpacked {
    char a;      // 1 byte
    int b;       // 4 bytes (may have 3 bytes padding before)
    char c;      // 1 byte (may have 3 bytes padding after)
};

#pragma pack(1)
struct Packed {
    char a;      // 1 byte
    int b;       // 4 bytes (no padding)
    char c;      // 1 byte (no padding)
};
#pragma pack()

int main() {
    printf("Size of Unpacked: %zu bytes\n", sizeof(struct Unpacked));
    printf("Size of Packed: %zu bytes\n", sizeof(struct Packed));
    
    // Show member offsets
    struct Unpacked u = {0};
    printf("Unpacked offsets - a: %td, b: %td, c: %td\n",
           (char*)&u.a - (char*)&u,
           (char*)&u.b - (char*)&u,
           (char*)&u.c - (char*)&u);
    
    struct Packed p = {0};
    printf("Packed offsets - a: %td, b: %td, c: %td\n",
           (char*)&p.a - (char*)&p,
           (char*)&p.b - (char*)&p,
           (char*)&p.c - (char*)&p);
    
    return 0;
}

Controlling Alignment with Pragma Pack

The #pragma pack directive controls structure packing:

#include <stdio.h>

// Default alignment
struct Default {
    char a;
    int b;
    char c;
};

// 1-byte alignment (no padding)
#pragma pack(1)
struct Packed1 {
    char a;
    int b;
    char c;
};
#pragma pack()

// 2-byte alignment
#pragma pack(2)
struct Packed2 {
    char a;
    int b;
    char c;
};
#pragma pack()

// 4-byte alignment
#pragma pack(4)
struct Packed4 {
    char a;
    int b;
    char c;
};
#pragma pack()

int main() {
    printf("Default alignment: %zu bytes\n", sizeof(struct Default));
    printf("1-byte packing: %zu bytes\n", sizeof(struct Packed1));
    printf("2-byte packing: %zu bytes\n", sizeof(struct Packed2));
    printf("4-byte packing: %zu bytes\n", sizeof(struct Packed4));
    
    return 0;
}

Using _Alignas (C11)

C11 introduces _Alignas for explicit alignment control:

#include <stdio.h>
#include <stdalign.h>

struct AlignedStruct {
    _Alignas(16) char data[16];  // Align to 16-byte boundary
    int value;
};

int main() {
    struct AlignedStruct s = {0};
    
    printf("Size: %zu bytes\n", sizeof(s));
    printf("Address of data: %p\n", (void*)s.data);
    printf("Alignment of data: %zu\n", (size_t)s.data % 16);
    
    return 0;
}

Flexible Array Members (C99)

Basic Flexible Array Member

Flexible array members allow structures to have variable-sized arrays at the end:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct DynamicArray {
    size_t count;
    int data[];  // Flexible array member (must be last)
};

struct DynamicArray* create_array(size_t count) {
    // Allocate memory for structure + array
    struct DynamicArray *arr = malloc(sizeof(struct DynamicArray) + 
                                     count * sizeof(int));
    if (arr != NULL) {
        arr->count = count;
        // arr->data can now be used as array of 'count' integers
    }
    return arr;
}

int main() {
    struct DynamicArray *arr = create_array(5);
    if (arr != NULL) {
        // Initialize array elements
        for (size_t i = 0; i < arr->count; i++) {
            arr->data[i] = (int)(i * i);
        }
        
        // Print array elements
        printf("Array elements: ");
        for (size_t i = 0; i < arr->count; i++) {
            printf("%d ", arr->data[i]);
        }
        printf("\n");
        
        printf("Size of structure: %zu bytes\n", sizeof(struct DynamicArray));
        printf("Total allocated size: %zu bytes\n", 
               sizeof(struct DynamicArray) + arr->count * sizeof(int));
        
        // Free memory
        free(arr);
    }
    
    return 0;
}

Flexible Array in String Structure

Using flexible array members for dynamic strings:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct DynamicString {
    size_t length;
    char data[];  // Flexible array member
};

struct DynamicString* create_string(const char *source) {
    size_t len = strlen(source);
    // Allocate memory for structure + string + null terminator
    struct DynamicString *str = malloc(sizeof(struct DynamicString) + 
                                      len + 1);
    if (str != NULL) {
        str->length = len;
        strcpy(str->data, source);
    }
    return str;
}

struct DynamicString* append_strings(const struct DynamicString *s1, 
                                   const char *s2) {
    size_t len2 = strlen(s2);
    size_t new_len = s1->length + len2;
    
    struct DynamicString *result = malloc(sizeof(struct DynamicString) + 
                                         new_len + 1);
    if (result != NULL) {
        result->length = new_len;
        strcpy(result->data, s1->data);
        strcat(result->data, s2);
    }
    return result;
}

int main() {
    struct DynamicString *str1 = create_string("Hello, ");
    if (str1 != NULL) {
        printf("String 1: %s (length: %zu)\n", str1->data, str1->length);
        
        struct DynamicString *str2 = append_strings(str1, "World!");
        if (str2 != NULL) {
            printf("String 2: %s (length: %zu)\n", str2->data, str2->length);
            free(str2);
        }
        
        free(str1);
    }
    
    return 0;
}

Self-Referential Structures

Linked List Implementation

Self-referential structures are fundamental for implementing linked data structures:

#include <stdio.h>
#include <stdlib.h>

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

// Function to create a new node
struct Node* create_node(int data) {
    struct Node *node = malloc(sizeof(struct Node));
    if (node != NULL) {
        node->data = data;
        node->next = NULL;
    }
    return node;
}

// Function to insert at beginning
struct Node* insert_at_beginning(struct Node *head, int data) {
    struct Node *new_node = create_node(data);
    if (new_node != NULL) {
        new_node->next = head;
        head = new_node;
    }
    return head;
}

// Function to print the list
void print_list(struct Node *head) {
    struct Node *current = head;
    while (current != NULL) {
        printf("%d -> ", current->data);
        current = current->next;
    }
    printf("NULL\n");
}

// Function to free the list
void free_list(struct Node *head) {
    struct Node *current = head;
    while (current != NULL) {
        struct Node *next = current->next;
        free(current);
        current = next;
    }
}

int main() {
    struct Node *head = NULL;
    
    // Build the list: 3 -> 2 -> 1 -> NULL
    head = insert_at_beginning(head, 1);
    head = insert_at_beginning(head, 2);
    head = insert_at_beginning(head, 3);
    
    printf("Linked List: ");
    print_list(head);
    
    // Free the list
    free_list(head);
    
    return 0;
}

Binary Tree Implementation

Self-referential structures for binary trees:

#include <stdio.h>
#include <stdlib.h>

struct TreeNode {
    int data;
    struct TreeNode *left;
    struct TreeNode *right;
};

// Function to create a new node
struct TreeNode* create_node(int data) {
    struct TreeNode *node = malloc(sizeof(struct TreeNode));
    if (node != NULL) {
        node->data = data;
        node->left = NULL;
        node->right = NULL;
    }
    return node;
}

// Function to insert a node in BST
struct TreeNode* insert(struct TreeNode *root, int data) {
    if (root == NULL) {
        return create_node(data);
    }
    
    if (data < root->data) {
        root->left = insert(root->left, data);
    } else if (data > root->data) {
        root->right = insert(root->right, data);
    }
    
    return root;
}

// In-order traversal
void inorder_traversal(struct TreeNode *root) {
    if (root != NULL) {
        inorder_traversal(root->left);
        printf("%d ", root->data);
        inorder_traversal(root->right);
    }
}

// Free the tree
void free_tree(struct TreeNode *root) {
    if (root != NULL) {
        free_tree(root->left);
        free_tree(root->right);
        free(root);
    }
}

int main() {
    struct TreeNode *root = NULL;
    
    // Insert nodes
    root = insert(root, 50);
    insert(root, 30);
    insert(root, 70);
    insert(root, 20);
    insert(root, 40);
    insert(root, 60);
    insert(root, 80);
    
    printf("In-order traversal: ");
    inorder_traversal(root);
    printf("\n");
    
    // Free the tree
    free_tree(root);
    
    return 0;
}

Advanced Structure Techniques

Structure with Function Pointers (C Object-Oriented Approach)

Using function pointers to implement object-oriented concepts in C:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// Forward declaration
struct Shape;

// Function pointer types
typedef double (*area_func)(const struct Shape *self);
typedef void (*print_func)(const struct Shape *self);

// Base structure
struct Shape {
    area_func area;
    print_func print;
    char name[20];
};

// Rectangle structure
struct Rectangle {
    struct Shape base;
    double width;
    double height;
};

// Circle structure
struct Circle {
    struct Shape base;
    double radius;
};

// Area calculation functions
double rectangle_area(const struct Shape *self) {
    const struct Rectangle *rect = (const struct Rectangle *)self;
    return rect->width * rect->height;
}

double circle_area(const struct Shape *self) {
    const struct Circle *circle = (const struct Circle *)self;
    return 3.14159 * circle->radius * circle->radius;
}

// Print functions
void rectangle_print(const struct Shape *self) {
    const struct Rectangle *rect = (const struct Rectangle *)self;
    printf("Rectangle: %s, Width: %.2f, Height: %.2f\n",
           self->name, rect->width, rect->height);
}

void circle_print(const struct Shape *self) {
    const struct Circle *circle = (const struct Circle *)self;
    printf("Circle: %s, Radius: %.2f\n",
           self->name, circle->radius);
}

// Constructor functions
struct Rectangle* create_rectangle(const char *name, double width, double height) {
    struct Rectangle *rect = malloc(sizeof(struct Rectangle));
    if (rect != NULL) {
        strncpy(rect->base.name, name, sizeof(rect->base.name) - 1);
        rect->base.name[sizeof(rect->base.name) - 1] = '\0';
        rect->base.area = rectangle_area;
        rect->base.print = rectangle_print;
        rect->width = width;
        rect->height = height;
    }
    return rect;
}

struct Circle* create_circle(const char *name, double radius) {
    struct Circle *circle = malloc(sizeof(struct Circle));
    if (circle != NULL) {
        strncpy(circle->base.name, name, sizeof(circle->base.name) - 1);
        circle->base.name[sizeof(circle->base.name) - 1] = '\0';
        circle->base.area = circle_area;
        circle->base.print = circle_print;
        circle->radius = radius;
    }
    return circle;
}

int main() {
    struct Rectangle *rect = create_rectangle("MyRectangle", 5.0, 3.0);
    struct Circle *circle = create_circle("MyCircle", 4.0);
    
    if (rect != NULL && circle != NULL) {
        // Polymorphic behavior
        struct Shape *shapes[] = {
            (struct Shape*)rect,
            (struct Shape*)circle
        };
        
        for (int i = 0; i < 2; i++) {
            shapes[i]->print(shapes[i]);
            printf("Area: %.2f\n", shapes[i]->area(shapes[i]));
        }
        
        free(rect);
        free(circle);
    }
    
    return 0;
}

Structure with Nested Anonymous Structures (C11)

Using nested anonymous structures for cleaner APIs:

#include <stdio.h>

struct Point3D {
    union {
        struct {
            double x, y, z;
        };
        double coords[3];
    };
};

struct Color {
    union {
        struct {
            unsigned char r, g, b, a;
        };
        unsigned char components[4];
    };
};

int main() {
    struct Point3D point = {1.0, 2.0, 3.0};
    struct Color color = {255, 128, 64, 255};
    
    // Access using named members
    printf("Point: (%.1f, %.1f, %.1f)\n", point.x, point.y, point.z);
    
    // Access using array
    printf("Coordinates: ");
    for (int i = 0; i < 3; i++) {
        printf("%.1f ", point.coords[i]);
    }
    printf("\n");
    
    // Access color components
    printf("Color: RGBA(%d, %d, %d, %d)\n", 
           color.r, color.g, color.b, color.a);
    
    // Modify using array access
    for (int i = 0; i < 4; i++) {
        color.components[i] = 128;
    }
    
    printf("Modified color: RGBA(%d, %d, %d, %d)\n",
           color.r, color.g, color.b, color.a);
    
    return 0;
}

Practical Examples

Configuration Manager with Advanced Structures

Combining advanced structure concepts for a configuration manager:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// Configuration entry types
typedef enum {
    CONFIG_INT,
    CONFIG_FLOAT,
    CONFIG_STRING,
    CONFIG_BOOL
} ConfigType;

// Configuration entry with bit fields
struct ConfigEntry {
    unsigned int type : 3;        // 3 bits for type
    unsigned int is_default : 1;  // 1 bit for default flag
    unsigned int is_locked : 1;   // 1 bit for lock flag
    unsigned int reserved : 27;   // 27 bits reserved
    
    char key[32];
    union {
        int int_value;
        float float_value;
        char *string_value;
        int bool_value;
    } value;
};

// Configuration manager
struct ConfigManager {
    struct ConfigEntry *entries;
    size_t count;
    size_t capacity;
};

struct ConfigManager* create_config_manager() {
    struct ConfigManager *cm = malloc(sizeof(struct ConfigManager));
    if (cm != NULL) {
        cm->entries = malloc(10 * sizeof(struct ConfigEntry));
        if (cm->entries != NULL) {
            cm->count = 0;
            cm->capacity = 10;
        } else {
            free(cm);
            cm = NULL;
        }
    }
    return cm;
}

int add_int_config(struct ConfigManager *cm, const char *key, int value) {
    if (cm->count >= cm->capacity) {
        struct ConfigEntry *new_entries = realloc(cm->entries,
            (cm->capacity + 10) * sizeof(struct ConfigEntry));
        if (new_entries == NULL) return -1;
        cm->entries = new_entries;
        cm->capacity += 10;
    }
    
    struct ConfigEntry *entry = &cm->entries[cm->count];
    entry->type = CONFIG_INT;
    entry->is_default = 0;
    entry->is_locked = 0;
    entry->reserved = 0;
    strncpy(entry->key, key, sizeof(entry->key) - 1);
    entry->key[sizeof(entry->key) - 1] = '\0';
    entry->value.int_value = value;
    
    cm->count++;
    return 0;
}

void print_config(const struct ConfigManager *cm) {
    for (size_t i = 0; i < cm->count; i++) {
        const struct ConfigEntry *entry = &cm->entries[i];
        printf("Key: %s, Type: %d, Default: %d, Locked: %d\n",
               entry->key, entry->type, entry->is_default, entry->is_locked);
        
        switch (entry->type) {
            case CONFIG_INT:
                printf("  Value: %d (int)\n", entry->value.int_value);
                break;
            // Add other cases as needed
        }
    }
}

void free_config_manager(struct ConfigManager *cm) {
    if (cm != NULL) {
        free(cm->entries);
        free(cm);
    }
}

int main() {
    struct ConfigManager *cm = create_config_manager();
    if (cm == NULL) {
        printf("Failed to create config manager\n");
        return 1;
    }
    
    add_int_config(cm, "window_width", 800);
    add_int_config(cm, "window_height", 600);
    add_int_config(cm, "max_fps", 60);
    
    print_config(cm);
    
    free_config_manager(cm);
    return 0;
}

Memory Pool with Flexible Array Members

Implementing a memory pool using flexible array members:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct MemoryBlock {
    size_t size;
    int is_free;
    char data[];  // Flexible array member
};

struct MemoryPool {
    size_t block_size;
    size_t total_blocks;
    struct MemoryBlock blocks[];  // Flexible array member
};

struct MemoryPool* create_memory_pool(size_t block_size, size_t num_blocks) {
    size_t pool_size = sizeof(struct MemoryPool) + 
                      num_blocks * (sizeof(struct MemoryBlock) + block_size);
    
    struct MemoryPool *pool = malloc(pool_size);
    if (pool != NULL) {
        pool->block_size = block_size;
        pool->total_blocks = num_blocks;
        
        // Initialize blocks
        char *block_data = (char*)(pool->blocks);
        for (size_t i = 0; i < num_blocks; i++) {
            struct MemoryBlock *block = (struct MemoryBlock*)block_data;
            block->size = block_size;
            block->is_free = 1;
            block_data += sizeof(struct MemoryBlock) + block_size;
        }
    }
    return pool;
}

void* pool_alloc(struct MemoryPool *pool, size_t size) {
    if (size > pool->block_size) return NULL;
    
    char *block_data = (char*)(pool->blocks);
    for (size_t i = 0; i < pool->total_blocks; i++) {
        struct MemoryBlock *block = (struct MemoryBlock*)block_data;
        if (block->is_free && block->size >= size) {
            block->is_free = 0;
            return block->data;
        }
        block_data += sizeof(struct MemoryBlock) + pool->block_size;
    }
    return NULL;
}

void pool_free(struct MemoryPool *pool, void *ptr) {
    if (ptr == NULL) return;
    
    char *pool_start = (char*)pool;
    char *ptr_char = (char*)ptr;
    
    if (ptr_char >= pool_start && 
        ptr_char < pool_start + sizeof(struct MemoryPool) + 
                   pool->total_blocks * (sizeof(struct MemoryBlock) + pool->block_size)) {
        
        char *block_data = (char*)(pool->blocks);
        for (size_t i = 0; i < pool->total_blocks; i++) {
            struct MemoryBlock *block = (struct MemoryBlock*)block_data;
            if (ptr_char == block->data) {
                block->is_free = 1;
                return;
            }
            block_data += sizeof(struct MemoryBlock) + pool->block_size;
        }
    }
}

void free_memory_pool(struct MemoryPool *pool) {
    free(pool);
}

int main() {
    struct MemoryPool *pool = create_memory_pool(64, 10);
    if (pool == NULL) {
        printf("Failed to create memory pool\n");
        return 1;
    }
    
    // Allocate memory from pool
    int *numbers = (int*)pool_alloc(pool, 10 * sizeof(int));
    if (numbers != NULL) {
        for (int i = 0; i < 10; i++) {
            numbers[i] = i * i;
        }
        
        printf("Numbers: ");
        for (int i = 0; i < 10; i++) {
            printf("%d ", numbers[i]);
        }
        printf("\n");
        
        // Free memory
        pool_free(pool, numbers);
    }
    
    free_memory_pool(pool);
    return 0;
}

Summary

Advanced structure concepts in C provide powerful mechanisms for creating efficient and sophisticated data representations:

1. Bit Fields: Enable precise control over memory usage for small values and hardware register representation
2. Structure Packing: Control memory alignment and padding for optimization
3. Flexible Array Members: Allow structures to have variable-sized arrays at the end (C99)
4. Self-Referential Structures: Enable implementation of linked data structures like lists and trees
5. Function Pointers in Structures: Support object-oriented programming concepts in C
6. Anonymous Structures: Provide cleaner APIs (C11)

These advanced concepts are essential for systems programming, embedded development, and performance-critical applications where memory efficiency and precise control over data representation are crucial.