C Development

Write safe, efficient C code for systems programming.

When to use Writing C code Memory management issues System programming Embedded systems Performance-critical code Memory management Allocation patterns // Always check malloc void* ptr = malloc(size); if (ptr == NULL) { fprintf(stderr, "malloc failed\n"); return -1; }

// Pair malloc with free char* buffer = malloc(1024); // ... use buffer ... free(buffer); buffer = NULL; // Prevent use-after-free

// Use calloc for zero-initialized memory int* array = calloc(count, sizeof(int));

// Realloc safely void* new_ptr = realloc(ptr, new_size); if (new_ptr == NULL) { free(ptr); // Original still valid on failure return -1; } ptr = new_ptr;

Common patterns // RAII-style cleanup with goto int process_file(const char path) { int result = -1; FILE fp = NULL; char* buffer = NULL;

fp = fopen(path, "r");
if (!fp) goto cleanup;

buffer = malloc(1024);
if (!buffer) goto cleanup;

// ... process ...
result = 0;

cleanup: free(buffer); if (fp) fclose(fp); return result; }

Data structures // Linked list node typedef struct Node { void data; struct Node next; } Node;

// Dynamic array typedef struct { void** items; size_t count; size_t capacity; } DynArray;

int dynarray_push(DynArray arr, void item) { if (arr->count >= arr->capacity) { size_t new_cap = arr->capacity ? arr->capacity * 2 : 8; void* new_items = realloc(arr->items, new_cap * sizeof(void)); if (!new_items) return -1; arr->items = new_items; arr->capacity = new_cap; } arr->items[arr->count++] = item; return 0; }

Error handling // Check all system calls int fd = open(path, O_RDONLY); if (fd == -1) { perror("open"); return -1; }

ssize_t n = read(fd, buf, sizeof(buf)); if (n == -1) { perror("read"); close(fd); return -1; }

Debugging

Compile with debug symbols

gcc -g -Wall -Wextra -Werror -o prog prog.c

Run with valgrind

valgrind --leak-check=full ./prog

GDB debugging

gdb ./prog (gdb) break main (gdb) run (gdb) print variable (gdb) backtrace

Best practices Check all return values Initialize all variables Use const where possible Prefer stack over heap when size is known Use -Wall -Wextra -Werror flags Examples

Input: "Fix memory leak" Action: Run valgrind, trace allocation, ensure every malloc has free

Input: "Optimize this C code" Action: Profile with perf, identify hotspots, optimize critical path