C语言调试技巧和性能优化实战指南

调试和性能优化是C语言开发中的重要技能。本文将深入探讨各种调试技巧、性能分析方法和代码优化策略，帮助开发者编写更加高效、可靠的C程序。

1. 调试基础与工具

1.1 编译器调试选项

// 调试编译选项示例
// gcc -g -O0 -Wall -Wextra -DDEBUG program.c -o program

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

// 调试宏定义
#ifdef DEBUG
    #define DBG_PRINT(fmt, ...) \
        fprintf(stderr, "[DEBUG] %s:%d:%s(): " fmt "\n", \
                __FILE__, __LINE__, __func__, ##__VA_ARGS__)
    #define DBG_ENTER() \
        fprintf(stderr, "[ENTER] %s:%d:%s()\n", \
                __FILE__, __LINE__, __func__)
    #define DBG_EXIT() \
        fprintf(stderr, "[EXIT] %s:%d:%s()\n", \
                __FILE__, __LINE__, __func__)
#else
    #define DBG_PRINT(fmt, ...)
    #define DBG_ENTER()
    #define DBG_EXIT()
#endif

// 断言宏
#define ASSERT_NOT_NULL(ptr) \
    do { \
        if ((ptr) == NULL) { \
            fprintf(stderr, "Assertion failed: %s is NULL at %s:%d\n", \
                    #ptr, __FILE__, __LINE__); \
            abort(); \
        } \
    } while(0)

#define ASSERT_RANGE(val, min, max) \
    do { \
        if ((val) < (min) || (val) > (max)) { \
            fprintf(stderr, "Assertion failed: %s (%d) not in range [%d, %d] at %s:%d\n", \
                    #val, (val), (min), (max), __FILE__, __LINE__); \
            abort(); \
        } \
    } while(0)

// 错误处理宏
#define CHECK_ERRNO(expr) \
    do { \
        if ((expr) == -1) { \
            fprintf(stderr, "Error at %s:%d: %s\n", \
                    __FILE__, __LINE__, strerror(errno)); \
            exit(EXIT_FAILURE); \
        } \
    } while(0)

#define CHECK_NULL(ptr) \
    do { \
        if ((ptr) == NULL) { \
            fprintf(stderr, "Null pointer at %s:%d\n", \
                    __FILE__, __LINE__); \
            exit(EXIT_FAILURE); \
        } \
    } while(0)

1.2 内存调试工具

// 自定义内存分配跟踪
#ifdef DEBUG_MEMORY

typedef struct MemoryBlock {
    void *ptr;
    size_t size;
    const char *file;
    int line;
    struct MemoryBlock *next;
} MemoryBlock;

static MemoryBlock *memory_blocks = NULL;
static size_t total_allocated = 0;
static size_t allocation_count = 0;

// 调试版本的malloc
void* debug_malloc(size_t size, const char *file, int line) {
    void *ptr = malloc(size);
    if (!ptr) return NULL;
    
    MemoryBlock *block = (MemoryBlock*)malloc(sizeof(MemoryBlock));
    if (block) {
        block->ptr = ptr;
        block->size = size;
        block->file = file;
        block->line = line;
        block->next = memory_blocks;
        memory_blocks = block;
        
        total_allocated += size;
        allocation_count++;
        
        printf("[MALLOC] %p (%zu bytes) at %s:%d\n", ptr, size, file, line);
    }
    
    return ptr;
}

// 调试版本的free
void debug_free(void *ptr, const char *file, int line) {
    if (!ptr) return;
    
    MemoryBlock *current = memory_blocks;
    MemoryBlock *prev = NULL;
    
    while (current) {
        if (current->ptr == ptr) {
            if (prev) {
                prev->next = current->next;
            } else {
                memory_blocks = current->next;
            }
            
            total_allocated -= current->size;
            allocation_count--;
            
            printf("[FREE] %p (%zu bytes) at %s:%d (allocated at %s:%d)\n", 
                   ptr, current->size, file, line, current->file, current->line);
            
            free(current);
            free(ptr);
            return;
        }
        prev = current;
        current = current->next;
    }
    
    printf("[ERROR] Attempting to free unallocated pointer %p at %s:%d\n", 
           ptr, file, line);
}

// 内存泄漏检查
void check_memory_leaks() {
    if (memory_blocks) {
        printf("\n=== MEMORY LEAKS DETECTED ===\n");
        MemoryBlock *current = memory_blocks;
        while (current) {
            printf("Leaked: %p (%zu bytes) allocated at %s:%d\n", 
                   current->ptr, current->size, current->file, current->line);
            current = current->next;
        }
        printf("Total leaked: %zu bytes in %zu allocations\n", 
               total_allocated, allocation_count);
    } else {
        printf("No memory leaks detected.\n");
    }
}

#define malloc(size) debug_malloc(size, __FILE__, __LINE__)
#define free(ptr) debug_free(ptr, __FILE__, __LINE__)

#endif // DEBUG_MEMORY

1.3 GDB调试技巧

// GDB调试辅助函数
void print_array(int *arr, int size) {
    printf("Array contents: ");
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

void print_linked_list(struct ListNode *head) {
    printf("List: ");
    while (head) {
        printf("%d -> ", head->data);
        head = head->next;
    }
    printf("NULL\n");
}

// 调试信息结构
typedef struct {
    const char *function_name;
    int call_count;
    double total_time;
} FunctionStats;

// 函数调用统计
#ifdef PROFILE_FUNCTIONS
#include <time.h>

static FunctionStats function_stats[100];
static int stats_count = 0;

void profile_function_enter(const char *func_name) {
    // 查找或创建统计项
    for (int i = 0; i < stats_count; i++) {
        if (strcmp(function_stats[i].function_name, func_name) == 0) {
            function_stats[i].call_count++;
            return;
        }
    }
    
    if (stats_count < 100) {
        function_stats[stats_count].function_name = func_name;
        function_stats[stats_count].call_count = 1;
        function_stats[stats_count].total_time = 0.0;
        stats_count++;
    }
}

void print_function_stats() {
    printf("\n=== FUNCTION CALL STATISTICS ===\n");
    for (int i = 0; i < stats_count; i++) {
        printf("%s: %d calls\n", 
               function_stats[i].function_name, 
               function_stats[i].call_count);
    }
}

#define PROFILE_ENTER() profile_function_enter(__func__)
#else
#define PROFILE_ENTER()
#endif

2. 性能分析工具

2.1 时间测量

#include <time.h>
#include <sys/time.h>

// 高精度时间测量
typedef struct {
    struct timespec start;
    struct timespec end;
} Timer;

void timer_start(Timer *timer) {
    clock_gettime(CLOCK_MONOTONIC, &timer->start);
}

double timer_end(Timer *timer) {
    clock_gettime(CLOCK_MONOTONIC, &timer->end);
    
    double start_sec = timer->start.tv_sec + timer->start.tv_nsec / 1e9;
    double end_sec = timer->end.tv_sec + timer->end.tv_nsec / 1e9;
    
    return end_sec - start_sec;
}

// 性能测试宏
#define BENCHMARK(code_block) \
    do { \
        Timer timer; \
        timer_start(&timer); \
        code_block \
        double elapsed = timer_end(&timer); \
        printf("Execution time: %.6f seconds\n", elapsed); \
    } while(0)

// 函数性能分析器
typedef struct {
    const char *name;
    double min_time;
    double max_time;
    double total_time;
    int call_count;
} PerformanceStats;

static PerformanceStats perf_stats[50];
static int perf_count = 0;

void perf_record(const char *func_name, double execution_time) {
    for (int i = 0; i < perf_count; i++) {
        if (strcmp(perf_stats[i].name, func_name) == 0) {
            perf_stats[i].total_time += execution_time;
            perf_stats[i].call_count++;
            
            if (execution_time < perf_stats[i].min_time) {
                perf_stats[i].min_time = execution_time;
            }
            if (execution_time > perf_stats[i].max_time) {
                perf_stats[i].max_time = execution_time;
            }
            return;
        }
    }
    
    if (perf_count < 50) {
        perf_stats[perf_count].name = func_name;
        perf_stats[perf_count].min_time = execution_time;
        perf_stats[perf_count].max_time = execution_time;
        perf_stats[perf_count].total_time = execution_time;
        perf_stats[perf_count].call_count = 1;
        perf_count++;
    }
}

void print_performance_report() {
    printf("\n=== PERFORMANCE REPORT ===\n");
    printf("%-20s %8s %12s %12s %12s %12s\n", 
           "Function", "Calls", "Total(s)", "Avg(s)", "Min(s)", "Max(s)");
    printf("--------------------------------------------------------------------\n");
    
    for (int i = 0; i < perf_count; i++) {
        double avg_time = perf_stats[i].total_time / perf_stats[i].call_count;
        printf("%-20s %8d %12.6f %12.6f %12.6f %12.6f\n",
               perf_stats[i].name,
               perf_stats[i].call_count,
               perf_stats[i].total_time,
               avg_time,
               perf_stats[i].min_time,
               perf_stats[i].max_time);
    }
}

// 自动性能测量宏
#define PERF_MEASURE(func_name, code_block) \
    do { \
        Timer timer; \
        timer_start(&timer); \
        code_block \
        double elapsed = timer_end(&timer); \
        perf_record(func_name, elapsed); \
    } while(0)

2.2 内存使用分析

#include <sys/resource.h>

// 内存使用统计
typedef struct {
    size_t peak_memory;
    size_t current_memory;
    size_t total_allocations;
    size_t total_deallocations;
} MemoryStats;

static MemoryStats mem_stats = {0};

void update_memory_stats(size_t size, int is_allocation) {
    if (is_allocation) {
        mem_stats.current_memory += size;
        mem_stats.total_allocations++;
        
        if (mem_stats.current_memory > mem_stats.peak_memory) {
            mem_stats.peak_memory = mem_stats.current_memory;
        }
    } else {
        mem_stats.current_memory -= size;
        mem_stats.total_deallocations++;
    }
}

// 获取系统内存使用情况
void print_system_memory_usage() {
    struct rusage usage;
    if (getrusage(RUSAGE_SELF, &usage) == 0) {
        printf("System Memory Usage:\n");
        printf("  Max RSS: %ld KB\n", usage.ru_maxrss);
        printf("  Page faults: %ld\n", usage.ru_majflt + usage.ru_minflt);
    }
}

void print_memory_stats() {
    printf("\n=== MEMORY STATISTICS ===\n");
    printf("Peak memory usage: %zu bytes\n", mem_stats.peak_memory);
    printf("Current memory usage: %zu bytes\n", mem_stats.current_memory);
    printf("Total allocations: %zu\n", mem_stats.total_allocations);
    printf("Total deallocations: %zu\n", mem_stats.total_deallocations);
    printf("Memory leaks: %zu allocations\n", 
           mem_stats.total_allocations - mem_stats.total_deallocations);
    
    print_system_memory_usage();
}

3. 代码优化技巧

3.1 算法优化

// 示例：优化查找算法

// 未优化版本：线性查找
int linear_search(int *arr, int size, int target) {
    for (int i = 0; i < size; i++) {
        if (arr[i] == target) {
            return i;
        }
    }
    return -1;
}

// 优化版本：二分查找（需要有序数组）
int binary_search(int *arr, int size, int target) {
    int left = 0, right = size - 1;
    
    while (left <= right) {
        int mid = left + (right - left) / 2;
        
        if (arr[mid] == target) {
            return mid;
        } else if (arr[mid] < target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    
    return -1;
}

// 哈希表查找（O(1)平均时间复杂度）
#define HASH_SIZE 1024

typedef struct HashNode {
    int key;
    int value;
    struct HashNode *next;
} HashNode;

typedef struct {
    HashNode *buckets[HASH_SIZE];
} HashTable;

unsigned int hash_function(int key) {
    return ((unsigned int)key * 2654435761U) % HASH_SIZE;
}

int hash_search(HashTable *table, int key) {
    unsigned int index = hash_function(key);
    HashNode *node = table->buckets[index];
    
    while (node) {
        if (node->key == key) {
            return node->value;
        }
        node = node->next;
    }
    
    return -1;
}

// 缓存友好的数组访问
void matrix_multiply_optimized(int **a, int **b, int **c, int n) {
    // 分块矩阵乘法，提高缓存命中率
    const int BLOCK_SIZE = 64;
    
    for (int ii = 0; ii < n; ii += BLOCK_SIZE) {
        for (int jj = 0; jj < n; jj += BLOCK_SIZE) {
            for (int kk = 0; kk < n; kk += BLOCK_SIZE) {
                // 处理块内元素
                for (int i = ii; i < ii + BLOCK_SIZE && i < n; i++) {
                    for (int j = jj; j < jj + BLOCK_SIZE && j < n; j++) {
                        int sum = 0;
                        for (int k = kk; k < kk + BLOCK_SIZE && k < n; k++) {
                            sum += a[i][k] * b[k][j];
                        }
                        c[i][j] += sum;
                    }
                }
            }
        }
    }
}

3.2 内存优化

// 内存池实现
typedef struct MemoryPool {
    void *memory;
    size_t block_size;
    size_t block_count;
    void **free_blocks;
    int free_count;
} MemoryPool;

MemoryPool* memory_pool_create(size_t block_size, size_t block_count) {
    MemoryPool *pool = (MemoryPool*)malloc(sizeof(MemoryPool));
    if (!pool) return NULL;
    
    pool->block_size = block_size;
    pool->block_count = block_count;
    pool->memory = malloc(block_size * block_count);
    pool->free_blocks = (void**)malloc(sizeof(void*) * block_count);
    
    if (!pool->memory || !pool->free_blocks) {
        free(pool->memory);
        free(pool->free_blocks);
        free(pool);
        return NULL;
    }
    
    // 初始化空闲块链表
    char *ptr = (char*)pool->memory;
    for (size_t i = 0; i < block_count; i++) {
        pool->free_blocks[i] = ptr + i * block_size;
    }
    pool->free_count = block_count;
    
    return pool;
}

void* memory_pool_alloc(MemoryPool *pool) {
    if (!pool || pool->free_count == 0) {
        return NULL;
    }
    
    return pool->free_blocks[--pool->free_count];
}

void memory_pool_free(MemoryPool *pool, void *ptr) {
    if (!pool || !ptr || pool->free_count >= pool->block_count) {
        return;
    }
    
    pool->free_blocks[pool->free_count++] = ptr;
}

void memory_pool_destroy(MemoryPool *pool) {
    if (pool) {
        free(pool->memory);
        free(pool->free_blocks);
        free(pool);
    }
}

// 对象池模式
typedef struct Object {
    int id;
    char data[256];
    struct Object *next;  // 用于空闲链表
} Object;

typedef struct {
    Object *objects;
    Object *free_list;
    int capacity;
    int used_count;
} ObjectPool;

ObjectPool* object_pool_create(int capacity) {
    ObjectPool *pool = (ObjectPool*)malloc(sizeof(ObjectPool));
    if (!pool) return NULL;
    
    pool->objects = (Object*)malloc(sizeof(Object) * capacity);
    if (!pool->objects) {
        free(pool);
        return NULL;
    }
    
    pool->capacity = capacity;
    pool->used_count = 0;
    pool->free_list = NULL;
    
    // 初始化空闲链表
    for (int i = 0; i < capacity; i++) {
        pool->objects[i].next = pool->free_list;
        pool->free_list = &pool->objects[i];
    }
    
    return pool;
}

Object* object_pool_acquire(ObjectPool *pool) {
    if (!pool || !pool->free_list) {
        return NULL;
    }
    
    Object *obj = pool->free_list;
    pool->free_list = obj->next;
    pool->used_count++;
    
    // 重置对象状态
    memset(obj, 0, sizeof(Object));
    obj->next = NULL;
    
    return obj;
}

void object_pool_release(ObjectPool *pool, Object *obj) {
    if (!pool || !obj) return;
    
    obj->next = pool->free_list;
    pool->free_list = obj;
    pool->used_count--;
}

3.3 编译器优化

// 利用编译器优化提示

// 分支预测优化
#define likely(x)   __builtin_expect(!!(x), 1)
#define unlikely(x) __builtin_expect(!!(x), 0)

int optimized_search(int *arr, int size, int target) {
    for (int i = 0; i < size; i++) {
        if (unlikely(arr[i] == target)) {
            return i;
        }
    }
    return -1;
}

// 内联函数优化
static inline int fast_abs(int x) {
    return (x < 0) ? -x : x;
}

static inline int fast_min(int a, int b) {
    return (a < b) ? a : b;
}

static inline int fast_max(int a, int b) {
    return (a > b) ? a : b;
}

// 循环展开
void vector_add_unrolled(float *a, float *b, float *result, int size) {
    int i;
    
    // 处理4的倍数部分
    for (i = 0; i < size - 3; i += 4) {
        result[i] = a[i] + b[i];
        result[i + 1] = a[i + 1] + b[i + 1];
        result[i + 2] = a[i + 2] + b[i + 2];
        result[i + 3] = a[i + 3] + b[i + 3];
    }
    
    // 处理剩余元素
    for (; i < size; i++) {
        result[i] = a[i] + b[i];
    }
}

// 使用restrict关键字
void vector_multiply_restrict(float * restrict a, 
                             float * restrict b, 
                             float * restrict result, 
                             int size) {
    for (int i = 0; i < size; i++) {
        result[i] = a[i] * b[i];
    }
}

// SIMD优化示例（需要SSE支持）
#ifdef __SSE2__
#include <emmintrin.h>

void vector_add_simd(float *a, float *b, float *result, int size) {
    int simd_size = size - (size % 4);
    
    // SIMD处理
    for (int i = 0; i < simd_size; i += 4) {
        __m128 va = _mm_load_ps(&a[i]);
        __m128 vb = _mm_load_ps(&b[i]);
        __m128 vr = _mm_add_ps(va, vb);
        _mm_store_ps(&result[i], vr);
    }
    
    // 处理剩余元素
    for (int i = simd_size; i < size; i++) {
        result[i] = a[i] + b[i];
    }
}
#endif

4. 性能测试框架

4.1 基准测试

// 基准测试框架
typedef struct {
    const char *name;
    void (*setup)(void);
    void (*benchmark)(void);
    void (*teardown)(void);
    int iterations;
} Benchmark;

typedef struct {
    double min_time;
    double max_time;
    double avg_time;
    double total_time;
    int iterations;
} BenchmarkResult;

BenchmarkResult run_benchmark(Benchmark *bench) {
    BenchmarkResult result = {0};
    result.min_time = 1e9;
    result.max_time = 0;
    result.iterations = bench->iterations;
    
    printf("Running benchmark: %s (%d iterations)\n", 
           bench->name, bench->iterations);
    
    if (bench->setup) {
        bench->setup();
    }
    
    for (int i = 0; i < bench->iterations; i++) {
        Timer timer;
        timer_start(&timer);
        
        bench->benchmark();
        
        double elapsed = timer_end(&timer);
        result.total_time += elapsed;
        
        if (elapsed < result.min_time) {
            result.min_time = elapsed;
        }
        if (elapsed > result.max_time) {
            result.max_time = elapsed;
        }
    }
    
    if (bench->teardown) {
        bench->teardown();
    }
    
    result.avg_time = result.total_time / bench->iterations;
    
    printf("  Min: %.6f s, Max: %.6f s, Avg: %.6f s\n",
           result.min_time, result.max_time, result.avg_time);
    
    return result;
}

// 示例基准测试
static int *test_array;
static int array_size = 100000;
static int search_target = 50000;

void setup_search_test() {
    test_array = (int*)malloc(array_size * sizeof(int));
    for (int i = 0; i < array_size; i++) {
        test_array[i] = i;
    }
}

void benchmark_linear_search() {
    linear_search(test_array, array_size, search_target);
}

void benchmark_binary_search() {
    binary_search(test_array, array_size, search_target);
}

void teardown_search_test() {
    free(test_array);
}

void run_search_benchmarks() {
    Benchmark benchmarks[] = {
        {"Linear Search", setup_search_test, benchmark_linear_search, teardown_search_test, 1000},
        {"Binary Search", setup_search_test, benchmark_binary_search, teardown_search_test, 10000}
    };
    
    int num_benchmarks = sizeof(benchmarks) / sizeof(benchmarks[0]);
    
    for (int i = 0; i < num_benchmarks; i++) {
        run_benchmark(&benchmarks[i]);
    }
}

4.2 压力测试

// 压力测试框架
typedef struct {
    int max_memory_mb;
    int max_time_seconds;
    int max_operations;
    bool (*stress_function)(int iteration);
} StressTest;

bool run_stress_test(StressTest *test) {
    printf("Starting stress test...\n");
    printf("Max memory: %d MB, Max time: %d s, Max operations: %d\n",
           test->max_memory_mb, test->max_time_seconds, test->max_operations);
    
    Timer timer;
    timer_start(&timer);
    
    for (int i = 0; i < test->max_operations; i++) {
        // 检查时间限制
        if (i % 1000 == 0) {
            double elapsed = timer_end(&timer);
            timer_start(&timer);
            
            if (elapsed > test->max_time_seconds) {
                printf("Stress test stopped: time limit exceeded\n");
                return false;
            }
        }
        
        // 检查内存使用
        if (i % 10000 == 0) {
            struct rusage usage;
            if (getrusage(RUSAGE_SELF, &usage) == 0) {
                long memory_mb = usage.ru_maxrss / 1024;
                if (memory_mb > test->max_memory_mb) {
                    printf("Stress test stopped: memory limit exceeded (%ld MB)\n", memory_mb);
                    return false;
                }
            }
        }
        
        // 执行测试函数
        if (!test->stress_function(i)) {
            printf("Stress test failed at iteration %d\n", i);
            return false;
        }
    }
    
    printf("Stress test completed successfully\n");
    return true;
}

// 示例压力测试
bool memory_allocation_stress(int iteration) {
    void *ptr = malloc(1024);
    if (!ptr) return false;
    
    // 写入一些数据
    memset(ptr, iteration % 256, 1024);
    
    // 随机决定是否立即释放
    if (iteration % 2 == 0) {
        free(ptr);
    }
    
    return true;
}

void run_memory_stress_test() {
    StressTest test = {
        .max_memory_mb = 100,
        .max_time_seconds = 30,
        .max_operations = 1000000,
        .stress_function = memory_allocation_stress
    };
    
    run_stress_test(&test);
}

5. 实际优化案例

5.1 字符串处理优化

// 未优化版本
char* string_concat_slow(const char *str1, const char *str2) {
    int len1 = strlen(str1);
    int len2 = strlen(str2);
    char *result = (char*)malloc(len1 + len2 + 1);
    
    strcpy(result, str1);
    strcat(result, str2);
    
    return result;
}

// 优化版本
char* string_concat_fast(const char *str1, const char *str2) {
    int len1 = strlen(str1);
    int len2 = strlen(str2);
    char *result = (char*)malloc(len1 + len2 + 1);
    
    // 直接内存复制，避免重复扫描
    memcpy(result, str1, len1);
    memcpy(result + len1, str2, len2 + 1);  // 包含null终止符
    
    return result;
}

// 批量字符串连接优化
char* string_concat_multiple(const char **strings, int count) {
    // 首先计算总长度
    int total_length = 0;
    for (int i = 0; i < count; i++) {
        total_length += strlen(strings[i]);
    }
    
    char *result = (char*)malloc(total_length + 1);
    if (!result) return NULL;
    
    // 一次性复制所有字符串
    char *pos = result;
    for (int i = 0; i < count; i++) {
        int len = strlen(strings[i]);
        memcpy(pos, strings[i], len);
        pos += len;
    }
    *pos = '\0';
    
    return result;
}

5.2 数据结构优化

// 优化的动态数组实现
typedef struct {
    void *data;
    size_t element_size;
    size_t capacity;
    size_t size;
    double growth_factor;
} OptimizedArray;

OptimizedArray* array_create(size_t element_size, size_t initial_capacity) {
    OptimizedArray *arr = (OptimizedArray*)malloc(sizeof(OptimizedArray));
    if (!arr) return NULL;
    
    arr->element_size = element_size;
    arr->capacity = initial_capacity > 0 ? initial_capacity : 16;
    arr->size = 0;
    arr->growth_factor = 1.5;  // 更好的增长因子
    
    arr->data = malloc(arr->capacity * element_size);
    if (!arr->data) {
        free(arr);
        return NULL;
    }
    
    return arr;
}

int array_push(OptimizedArray *arr, const void *element) {
    if (!arr || !element) return -1;
    
    if (arr->size >= arr->capacity) {
        size_t new_capacity = (size_t)(arr->capacity * arr->growth_factor);
        void *new_data = realloc(arr->data, new_capacity * arr->element_size);
        if (!new_data) return -1;
        
        arr->data = new_data;
        arr->capacity = new_capacity;
    }
    
    char *dest = (char*)arr->data + arr->size * arr->element_size;
    memcpy(dest, element, arr->element_size);
    arr->size++;
    
    return 0;
}

// 批量操作优化
int array_push_batch(OptimizedArray *arr, const void *elements, size_t count) {
    if (!arr || !elements || count == 0) return -1;
    
    // 一次性扩容
    size_t required_capacity = arr->size + count;
    if (required_capacity > arr->capacity) {
        size_t new_capacity = arr->capacity;
        while (new_capacity < required_capacity) {
            new_capacity = (size_t)(new_capacity * arr->growth_factor);
        }
        
        void *new_data = realloc(arr->data, new_capacity * arr->element_size);
        if (!new_data) return -1;
        
        arr->data = new_data;
        arr->capacity = new_capacity;
    }
    
    // 批量复制
    char *dest = (char*)arr->data + arr->size * arr->element_size;
    memcpy(dest, elements, count * arr->element_size);
    arr->size += count;
    
    return 0;
}

6. 调试和优化最佳实践

6.1 代码审查清单

// 性能检查清单
void performance_checklist_example() {
    // 1. 避免不必要的函数调用
    int len = strlen(str);  // 缓存长度，避免重复计算
    for (int i = 0; i < len; i++) {
        // 使用缓存的长度
    }
    
    // 2. 减少内存分配
    char buffer[1024];  // 栈分配，而不是malloc
    
    // 3. 使用合适的数据类型
    uint32_t hash = 0;  // 明确的类型，避免隐式转换
    
    // 4. 避免深层嵌套循环
    // 考虑算法优化或数据结构改进
    
    // 5. 使用位操作优化
    if (n & 1) {  // 检查奇数，比 n % 2 更快
        // 处理奇数情况
    }
    
    // 6. 预分配内存
    char *buffer = malloc(expected_size);
    // 避免频繁的realloc
}

// 内存安全检查
void memory_safety_checklist() {
    // 1. 检查malloc返回值
    void *ptr = malloc(size);
    if (!ptr) {
        // 处理分配失败
        return;
    }
    
    // 2. 配对的malloc/free
    // 每个malloc都应该有对应的free
    
    // 3. 避免双重释放
    free(ptr);
    ptr = NULL;  // 防止意外重用
    
    // 4. 检查数组边界
    if (index >= 0 && index < array_size) {
        array[index] = value;
    }
    
    // 5. 初始化变量
    int value = 0;  // 明确初始化
    
    // 6. 使用const保护只读数据
    const char *readonly_string = "constant";
}

6.2 性能监控

// 运行时性能监控
typedef struct {
    const char *name;
    long long start_cycles;
    long long total_cycles;
    int call_count;
} PerformanceCounter;

static PerformanceCounter counters[32];
static int counter_count = 0;

// 获取CPU周期数（x86_64）
static inline long long get_cycles() {
#ifdef __x86_64__
    unsigned int lo, hi;
    __asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi));
    return ((long long)hi << 32) | lo;
#else
    return 0;  // 其他架构的实现
#endif
}

void perf_counter_start(const char *name) {
    for (int i = 0; i < counter_count; i++) {
        if (strcmp(counters[i].name, name) == 0) {
            counters[i].start_cycles = get_cycles();
            return;
        }
    }
    
    if (counter_count < 32) {
        counters[counter_count].name = name;
        counters[counter_count].start_cycles = get_cycles();
        counters[counter_count].total_cycles = 0;
        counters[counter_count].call_count = 0;
        counter_count++;
    }
}

void perf_counter_end(const char *name) {
    long long end_cycles = get_cycles();
    
    for (int i = 0; i < counter_count; i++) {
        if (strcmp(counters[i].name, name) == 0) {
            counters[i].total_cycles += end_cycles - counters[i].start_cycles;
            counters[i].call_count++;
            return;
        }
    }
}

void print_performance_counters() {
    printf("\n=== PERFORMANCE COUNTERS ===\n");
    for (int i = 0; i < counter_count; i++) {
        double avg_cycles = (double)counters[i].total_cycles / counters[i].call_count;
        printf("%s: %d calls, %.0f avg cycles\n", 
               counters[i].name, counters[i].call_count, avg_cycles);
    }
}

// 自动性能计数宏
#define PERF_COUNT(name, code) \
    do { \
        perf_counter_start(name); \
        code \
        perf_counter_end(name); \
    } while(0)

总结

本文全面介绍了C语言调试和性能优化的各种技巧和工具：

调试技巧：

• 编译器调试选项和宏定义
• 内存调试和泄漏检测
• GDB调试技巧和辅助函数
• 断言和错误处理机制

性能分析：

• 高精度时间测量
• 内存使用统计
• 函数调用分析
• 系统资源监控

代码优化：

• 算法和数据结构优化
• 内存管理优化
• 编译器优化技巧
• SIMD和并行优化

测试框架：

• 基准测试系统
• 压力测试工具
• 性能回归检测

最佳实践：

• 代码审查清单
• 性能监控方法
• 优化策略选择

掌握这些调试和优化技巧，能够帮助开发者：

• 快速定位和修复程序错误
• 识别性能瓶颈并进行针对性优化
• 编写更加高效、可靠的C语言程序
• 建立完善的性能测试和监控体系

记住，优化应该基于实际的性能测量数据，避免过早优化，始终保持代码的可读性和可维护性。

版权所有，如有侵权请联系我