用C语言实现内存管理接口

内存管理是编程中的一个重要部分。我们可以定义一个简单的内存管理接口，包括分配内存、释放内存以及内存使用情况的查询。下面是一个用C语言实现的示例：

内存管理接口

#ifndef MEMORY_MANAGER_H
#define MEMORY_MANAGER_H

#include <stddef.h>

// 初始化内存管理系统
void mem_manager_init(size_t total_size);

// 分配内存
void* mem_alloc(size_t size);

// 释放内存
void mem_free(void* ptr);

// 查询内存使用情况
size_t mem_total_size();
size_t mem_used_size();
size_t mem_free_size();

#endif // MEMORY_MANAGER_H

内存管理实现

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

// 内存管理结构体
typedef struct Block {
    size_t size;
    struct Block* next;
} Block;

static char* memory_pool = NULL;
static size_t total_size = 0;
static size_t used_size = 0;
static Block* free_list = NULL;

// 初始化内存管理系统
void mem_manager_init(size_t size) {
    if (memory_pool) {
        free(memory_pool);
    }

    memory_pool = (char*)malloc(size);
    if (!memory_pool) {
        perror("Failed to initialize memory pool");
        exit(EXIT_FAILURE);
    }

    total_size = size;
    used_size = 0;

    // Initialize free list with a single large block
    free_list = (Block*)memory_pool;
    free_list->size = size;
    free_list->next = NULL;
}

// 分配内存
void* mem_alloc(size_t size) {
    if (size == 0 || size + sizeof(Block) > total_size - used_size) {
        return NULL;
    }

    Block* prev = NULL;
    Block* curr = free_list;
    size_t total_size_needed = size + sizeof(Block);

    // Find a suitable block
    while (curr) {
        if (curr->size >= total_size_needed) {
            // Allocate memory
            if (curr->size > total_size_needed) {
                Block* next_block = (Block*)((char*)curr + total_size_needed);
                next_block->size = curr->size - total_size_needed;
                next_block->next = curr->next;
                curr->size = size;
                curr->next = next_block;
            } else {
                if (prev) {
                    prev->next = curr->next;
                } else {
                    free_list = curr->next;
                }
            }

            used_size += size;
            return (char*)curr + sizeof(Block);
        }

        prev = curr;
        curr = curr->next;
    }

    return NULL; // No suitable block found
}

// 释放内存
void mem_free(void* ptr) {
    if (!ptr) {
        return;
    }

    Block* block_to_free = (Block*)((char*)ptr - sizeof(Block));
    used_size -= block_to_free->size;

    // Insert the block back to the free list
    Block* curr = free_list;
    Block* prev = NULL;

    while (curr && (char*)curr < (char*)block_to_free) {
        prev = curr;
        curr = curr->next;
    }

    block_to_free->next = curr;
    if (prev) {
        prev->next = block_to_free;
    } else {
        free_list = block_to_free;
    }

    // Merge with adjacent blocks if possible
    if (curr && (char*)block_to_free + block_to_free->size + sizeof(Block) == (char*)curr) {
        block_to_free->size += curr->size + sizeof(Block);
        block_to_free->next = curr->next;
    }

    if (prev && (char*)prev + prev->size + sizeof(Block) == (char*)block_to_free) {
        prev->size += block_to_free->size + sizeof(Block);
        prev->next = block_to_free->next;
    }
}

// 查询内存使用情况
size_t mem_total_size() {
    return total_size;
}

size_t mem_used_size() {
    return used_size;
}

size_t mem_free_size() {
    return total_size - used_size;
}

使用示例

#include <stdio.h>
#include "memory_manager.h"

int main() {
    mem_manager_init(1024); // 初始化 1024 字节的内存池

    void* ptr1 = mem_alloc(100);
    void* ptr2 = mem_alloc(200);
    
    printf("Total size: %zu\n", mem_total_size());
    printf("Used size: %zu\n", mem_used_size());
    printf("Free size: %zu\n", mem_free_size());

    mem_free(ptr1);
    mem_free(ptr2);

    printf("After free:\n");
    printf("Used size: %zu\n", mem_used_size());
    printf("Free size: %zu\n", mem_free_size());

    return 0;
}

说明

• mem_manager_init(size_t total_size)：初始化内存管理系统，创建一个内存池。
• mem_alloc(size_t size)：从内存池中分配内存。
• mem_free(void* ptr)：释放之前分配的内存。
• mem_total_size()：查询总内存大小。
• mem_used_size()：查询已使用的内存大小。
• mem_free_size()：查询空闲的内存大小。

这个示例只是一个简单的内存管理实现，不适用于生产环境。它没有处理线程安全、内存碎片化等复杂问题。实际应用中可能需要更复杂和健壮的内存管理系统。