c-lang（克朗）

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