C语言内存管理

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

// 内存跟踪变量
static size_t total_allocated = 0;
static size_t total_freed = 0;

// 安全的内存分配函数
void* safe_malloc(size_t size) {
    void* ptr = malloc(size);
    if (ptr == NULL) {
        printf("内存分配失败\n");
        exit(1);
    }
    total_allocated += size;
    return ptr;
}

// 安全的内存重分配函数
void* safe_realloc(void* ptr, size_t size) {
    void* new_ptr = realloc(ptr, size);
    if (new_ptr == NULL) {
        printf("内存重分配失败\n");
        free(ptr);
        exit(1);
    }
    return new_ptr;
}

// 安全的内存释放函数
void safe_free(void* ptr) {
    if (ptr != NULL) {
        free(ptr);
        total_freed++;
    }
}

// 内存泄漏检查
void check_memory_leaks() {
    printf("内存使用统计：\n");
    printf("总分配次数：%zu\n", total_allocated);
    printf("总释放次数：%zu\n", total_freed);
    if (total_allocated != total_freed) {
        printf("警告：可能存在内存泄漏\n");
    }
}

// 内存池结构
typedef struct {
    void* memory;
    size_t size;
    size_t used;
} MemoryPool;

// 创建内存池
MemoryPool* create_memory_pool(size_t size) {
    MemoryPool* pool = safe_malloc(sizeof(MemoryPool));
    pool->memory = safe_malloc(size);
    pool->size = size;
    pool->used = 0;
    return pool;
}

// 从内存池分配内存
void* pool_alloc(MemoryPool* pool, size_t size) {
    if (pool->used + size > pool->size) {
        return NULL;
    }
    void* ptr = (char*)pool->memory + pool->used;
    pool->used += size;
    return ptr;
}

// 释放内存池
void free_memory_pool(MemoryPool* pool) {
    safe_free(pool->memory);
    safe_free(pool);
}

// 内存对齐
void* aligned_malloc(size_t size, size_t alignment) {
    void* ptr = NULL;
    if (posix_memalign(&ptr, alignment, size) != 0) {
        return NULL;
    }
    return ptr;
}

int main() {
    // 基本内存分配
    int* numbers = safe_malloc(5 * sizeof(int));
    for (int i = 0; i < 5; i++) {
        numbers[i] = i + 1;
    }
    
    // 内存重分配
    numbers = safe_realloc(numbers, 10 * sizeof(int));
    for (int i = 5; i < 10; i++) {
        numbers[i] = i + 1;
    }
    
    // 使用内存池
    MemoryPool* pool = create_memory_pool(1024);
    int* pool_numbers = pool_alloc(pool, 5 * sizeof(int));
    for (int i = 0; i < 5; i++) {
        pool_numbers[i] = i + 1;
    }
    
    // 内存对齐
    void* aligned_ptr = aligned_malloc(1024, 16);
    if (aligned_ptr != NULL) {
        printf("内存对齐成功\n");
        free(aligned_ptr);
    }
    
    // 内存泄漏检查
    check_memory_leaks();
    
    // 清理内存
    safe_free(numbers);
    free_memory_pool(pool);
    
    return 0;
}