C Advanced Topics and Best Practices

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <stdbool.h>
#include <time.h>
#include <assert.h>

// C99 features demonstration
typedef struct {
    char name[50];
    int age;
    float score;
} Student;

// Flexible array member (C99)
typedef struct {
    size_t count;
    Student students[]; // Flexible array member
} StudentList;

// Inline function (C99)
static inline int max(int a, int b) {
    return (a > b) ? a : b;
}

// Variable length arrays (C99)
void processVariableArray(int size) {
    int array[size]; // VLA
    
    for (int i = 0; i < size; i++) {
        array[i] = i * i;
    }
    
    printf("VLA processed with size %d\n", size);
}

// Compound literals (C99)
void printStudent(const Student *student) {
    printf("Name: %s, Age: %d, Score: %.2f\n", 
           student->name, student->age, student->score);
}

// Designated initializers (C99)
void demonstrateDesignatedInitializers() {
    Student student = {
        .name = "John Doe",
        .age = 25,
        .score = 95.5
    };
    
    printStudent(&student);
}

// Type-generic macros (C11)
#define print_value(x) _Generic((x),     int: printf("Integer: %d\n", (x)),     float: printf("Float: %.2f\n", (x)),     char*: printf("String: %s\n", (x)),     default: printf("Unknown type\n"))

// Memory alignment and padding
typedef struct {
    char a;     // 1 byte
    int b;      // 4 bytes
    char c;     // 1 byte
    double d;   // 8 bytes
} UnoptimizedStruct;

typedef struct {
    double d;   // 8 bytes
    int b;      // 4 bytes
    char a;     // 1 byte
    char c;     // 1 byte
} OptimizedStruct;

// Function pointers with different signatures
typedef int (*operation_t)(int, int);
typedef void (*callback_t)(const char*);

// Function pointer array
operation_t operations[] = {
    [0] = [](int a, int b) { return a + b; },
    [1] = [](int a, int b) { return a - b; },
    [2] = [](int a, int b) { return a * b; },
    [3] = [](int a, int b) { return (b != 0) ? a / b : 0; }
};

// Error handling with error codes
typedef enum {
    SUCCESS = 0,
    ERROR_NULL_POINTER,
    ERROR_INVALID_SIZE,
    ERROR_MEMORY_ALLOCATION,
    ERROR_FILE_OPERATION
} ErrorCode;

const char* getErrorMessage(ErrorCode code) {
    switch (code) {
        case SUCCESS: return "Success";
        case ERROR_NULL_POINTER: return "Null pointer error";
        case ERROR_INVALID_SIZE: return "Invalid size error";
        case ERROR_MEMORY_ALLOCATION: return "Memory allocation error";
        case ERROR_FILE_OPERATION: return "File operation error";
        default: return "Unknown error";
    }
}

// Safe memory allocation with error checking
void* safeMalloc(size_t size) {
    void *ptr = malloc(size);
    if (!ptr) {
        fprintf(stderr, "Memory allocation failed for size %zu\n", size);
        exit(EXIT_FAILURE);
    }
    return ptr;
}

// Safe string operations
char* safeStrdup(const char *str) {
    if (!str) return NULL;
    
    size_t len = strlen(str);
    char *dup = safeMalloc(len + 1);
    strcpy(dup, str);
    return dup;
}

// Safe string concatenation
char* safeStrcat(char *dest, const char *src, size_t dest_size) {
    if (!dest || !src) return dest;
    
    size_t dest_len = strlen(dest);
    size_t src_len = strlen(src);
    
    if (dest_len + src_len + 1 > dest_size) {
        fprintf(stderr, "Buffer overflow prevented\n");
        return dest;
    }
    
    strcat(dest, src);
    return dest;
}

// Performance measurement
typedef struct {
    clock_t start_time;
    clock_t end_time;
} Timer;

void startTimer(Timer *timer) {
    timer->start_time = clock();
}

void stopTimer(Timer *timer) {
    timer->end_time = clock();
}

double getElapsedTime(Timer *timer) {
    return (double)(timer->end_time - timer->start_time) / CLOCKS_PER_SEC;
}

// Algorithm optimization example
void optimizedBubbleSort(int arr[], int n) {
    bool swapped;
    for (int i = 0; i < n - 1; i++) {
        swapped = false;
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                // Swap using XOR (no temporary variable)
                arr[j] ^= arr[j + 1];
                arr[j + 1] ^= arr[j];
                arr[j] ^= arr[j + 1];
                swapped = true;
            }
        }
        if (!swapped) break; // Early termination
    }
}

// Memory pool implementation
typedef struct {
    void *pool;
    size_t size;
    size_t used;
    size_t block_size;
    void *free_list;
} MemoryPool;

MemoryPool* createMemoryPool(size_t total_size, size_t block_size) {
    MemoryPool *pool = safeMalloc(sizeof(MemoryPool));
    
    pool->pool = safeMalloc(total_size);
    pool->size = total_size;
    pool->used = 0;
    pool->block_size = block_size;
    pool->free_list = NULL;
    
    return pool;
}

void* poolAlloc(MemoryPool *pool) {
    if (pool->used + pool->block_size > pool->size) {
        return NULL;
    }
    
    void *ptr = (char*)pool->pool + pool->used;
    pool->used += pool->block_size;
    return ptr;
}

void freeMemoryPool(MemoryPool *pool) {
    if (pool) {
        free(pool->pool);
        free(pool);
    }
}

// Main demonstration function
int main() {
    printf("=== Advanced C Features and Best Practices Demo ===\n\n");
    
    // Demonstrate C99 features
    printf("1. C99 Features:\n");
    demonstrateDesignatedInitializers();
    
    int size = 5;
    processVariableArray(size);
    
    // Type-generic macros
    print_value(42);
    print_value(3.14f);
    print_value("Hello, C!");
    printf("\n");
    
    // Memory layout demonstration
    printf("2. Memory Layout:\n");
    printf("Unoptimized struct size: %zu\n", sizeof(UnoptimizedStruct));
    printf("Optimized struct size: %zu\n", sizeof(OptimizedStruct));
    printf("\n");
    
    // Function pointer demonstration
    printf("3. Function Pointers:\n");
    char *op_names[] = {"add", "subtract", "multiply", "divide"};
    int a = 10, b = 3;
    
    for (int i = 0; i < 4; i++) {
        int result = operations[i](a, b);
        printf("%s(%d, %d) = %d\n", op_names[i], a, b, result);
    }
    printf("\n");
    
    // Error handling demonstration
    printf("4. Error Handling:\n");
    ErrorCode codes[] = {SUCCESS, ERROR_NULL_POINTER, ERROR_INVALID_SIZE};
    for (int i = 0; i < 3; i++) {
        printf("Error %d: %s\n", codes[i], getErrorMessage(codes[i]));
    }
    printf("\n");
    
    // Performance measurement
    printf("5. Performance Measurement:\n");
    Timer timer;
    int test_array[1000];
    
    // Initialize test array
    for (int i = 0; i < 1000; i++) {
        test_array[i] = 1000 - i;
    }
    
    startTimer(&timer);
    optimizedBubbleSort(test_array, 1000);
    stopTimer(&timer);
    
    printf("Sorting 1000 elements took: %.6f seconds\n", getElapsedTime(&timer));
    printf("\n");
    
    // Memory pool demonstration
    printf("6. Memory Pool:\n");
    MemoryPool *pool = createMemoryPool(1024, 64);
    
    void *ptr1 = poolAlloc(pool);
    void *ptr2 = poolAlloc(pool);
    
    printf("Allocated 2 blocks from pool\n");
    printf("Pool usage: %zu/%zu bytes\n", pool->used, pool->size);
    
    freeMemoryPool(pool);
    printf("Memory pool freed\n\n");
    
    // Safe string operations
    printf("7. Safe String Operations:\n");
    char *dup_str = safeStrdup("Hello, World!");
    printf("Duplicated string: %s\n", dup_str);
    
    char buffer[50] = "Hello";
    safeStrcat(buffer, ", C Programming!", sizeof(buffer));
    printf("Concatenated string: %s\n", buffer);
    
    free(dup_str);
    printf("\n");
    
    printf("Demo completed successfully!\n");
    return 0;
}