C / C++ / 系统课时

实现任务新增和动态存储

实现任务新增和动态存储

任务管理器需要在运行期间不断接收新任务,因此不能依赖固定长度数组。本节用“堆上任务对象 + 可扩容指针数组”实现新增流程,让编号唯一、容量按需增长,并在任意一次内存申请失败时保持原有数据仍然可用。

学习目标

  • 设计可扩容的任务管理结构,并理解任务对象与指针数组的内存关系
  • 正确使用 malloc、calloc 和 realloc 处理新增与扩容
  • 在内存申请失败时避免覆盖旧指针、泄漏对象或错误消耗任务编号

用可扩容指针数组保存任务

管理器只把 Task * 放进动态数组,真正的 Task 对象分别申请在堆上。这样数组扩容时,即使 realloc 把指针数组移动到新地址,已经创建的任务对象本身也不会移动,后续建立哈希索引时可以稳定地保存任务指针。

初始容量设为 2,只是为了方便观察扩容。真实项目可以根据预计任务量选择更合适的初值;扩容通常按倍数增长,以减少频繁重新分配的次数。

任务管理器动态存储结构

实现新增任务

下面的完整程序实现初始化、自动扩容、新增任务、打印状态和释放内存。ensure_capacity 只负责扩容;task_manager_add 在容量准备成功后再创建任务,并且只有全部步骤成功才递增 next_id。

c
#include <limits.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
    unsigned long id;
    char title[64];
    int completed;
} Task;

typedef struct {
    Task **items;
    size_t size;
    size_t capacity;
    unsigned long next_id;
} TaskManager;

static int task_manager_init(TaskManager *manager, size_t initial_capacity) {
    manager->items = calloc(initial_capacity, sizeof(Task *));
    if (manager->items == NULL) {
        return 0;
    }

    manager->size = 0;
    manager->capacity = initial_capacity;
    manager->next_id = 1;
    return 1;
}

static int ensure_capacity(TaskManager *manager) {
    if (manager->size < manager->capacity) {
        return 1;
    }
    if (manager->capacity > SIZE_MAX / 2) {
        return 0;
    }

    size_t new_capacity = manager->capacity * 2;
    Task **new_items = realloc(
        manager->items,
        new_capacity * sizeof(Task *)
    );
    if (new_items == NULL) {
        return 0;
    }

    manager->items = new_items;
    manager->capacity = new_capacity;
    return 1;
}

static Task *task_manager_add(TaskManager *manager, const char *title) {
    if (manager->next_id == ULONG_MAX || !ensure_capacity(manager)) {
        return NULL;
    }

    Task *task = malloc(sizeof(Task));
    if (task == NULL) {
        return NULL;
    }

    task->id = manager->next_id;
    snprintf(task->title, sizeof(task->title), "%s", title);
    task->completed = 0;

    manager->items[manager->size++] = task;
    manager->next_id++;
    return task;
}

static void task_manager_destroy(TaskManager *manager) {
    for (size_t i = 0; i < manager->size; i++) {
        free(manager->items[i]);
    }
    free(manager->items);
}

int main(void) {
    TaskManager manager;
    if (!task_manager_init(&manager, 2)) {
        fprintf(stderr, "init failed\n");
        return 1;
    }

    if (task_manager_add(&manager, "write parser") == NULL ||
        task_manager_add(&manager, "add tests") == NULL ||
        task_manager_add(&manager, "review memory") == NULL) {
        fprintf(stderr, "add task failed\n");
        task_manager_destroy(&manager);
        return 1;
    }

    for (size_t i = 0; i < manager.size; i++) {
        Task *task = manager.items[i];
        printf("ID=%lu title=%s\n", task->id, task->title);
    }
    printf("size=%zu capacity=%zu nextId=%lu\n",
           manager.size, manager.capacity, manager.next_id);

    task_manager_destroy(&manager);
    return 0;
}

预期输出

text
ID=1 title=write parser
ID=2 title=add tests
ID=3 title=review memory
size=3 capacity=4 nextId=4

第三次新增前,size 与 capacity 都为 2,因此数组从 2 扩为 4。实际堆地址由运行时决定,不应把地址写进固定预期输出。

内存申请失败时保持旧状态

realloc 失败时会返回 NULL,但原内存仍然有效,所以不能直接写成 manager->items = realloc(...)。示例先把结果保存到 new_items,确认成功后再替换管理器中的指针。

新增任务也遵循“最后提交”原则:容量扩好、任务对象创建成功并初始化后,才写入数组并递增编号。这样任何一步失败都不会留下半条任务,也不会让下一次成功新增无故跳号。

释放时必须先逐个 free 任务对象,再释放保存这些指针的数组。两层内存的所有权分开处理,才能避免只释放数组却泄漏任务对象。

验收新增逻辑

可以用三个条件检查实现是否可靠:

  • 连续新增超过初始容量的任务,旧任务内容仍然正确,capacity 按预期增长。
  • 当新增函数返回 NULL 时,原有 size、任务内容和可访问指针保持不变。
  • 程序退出前每个成功创建的 Task 都被释放,动态指针数组也只释放一次。

这种结构为后续索引提供了稳定对象地址:管理器负责拥有任务,其他结构只保存 Task * 引用,不重复拥有和释放同一个任务。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

实现任务新增和动态存储

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通