The store starts empty (items == NULL). book_reserve is the one place that calls realloc: it doubles the capacity (starting at 4) only when the array is full, so a run of n appends costs O(n) total. We always assign realloc's result to a temporary first — if it returns NULL the original block is still valid and we have not leaked it. This is the dynamic-memory pattern from Module 2, Session 6.

contacts.c — store

void book_init(Book *b) {
    b->items    = NULL;
    b->count    = 0;
    b->capacity = 0;
    b->next_id  = 1;
}

/* Ensure room for at least `need` items. Returns 1 on success, 0 on
   allocation failure (leaving the existing buffer untouched). */
int book_reserve(Book *b, size_t need) {
    if (need <= b->capacity) return 1;          /* already big enough */

    size_t new_cap = b->capacity ? b->capacity : 4;
    while (new_cap < need) new_cap *= 2;          /* grow geometrically */

    /* realloc into a TEMP so we don't lose the old pointer on failure */
    Contact *tmp = realloc(b->items, new_cap * sizeof(Contact));
    if (tmp == NULL) {
        fprintf(stderr, "out of memory (wanted %zu slots)\n", new_cap);
        return 0;
    }
    b->items    = tmp;
    b->capacity = new_cap;
    return 1;
}

/* Append a copy of `c`, assigning it the next free id.
   Returns the new id, or -1 if the store could not grow. */
int book_add(Book *b, Contact c) {
    if (!book_reserve(b, b->count + 1)) return -1;
    c.id = b->next_id++;
    b->items[b->count++] = c;                     /* struct copy into the slot */
    return c.id;
}

/* Release the whole block and reset to the empty state. Calling
   book_free twice is safe because we NULL the pointer afterwards. */
void book_free(Book *b) {
    free(b->items);
    b->items    = NULL;
    b->count    = 0;
    b->capacity = 0;
}

book_find returns a pointer to the matching record (or NULL), so the caller can read or edit it in place — a direct use of the pointers & memory idea that a pointer is just an address into the array. book_delete removes by id while keeping the array contiguous: it shifts the tail down with memmove rather than leaving a hole. Order is not preserved guarantees here — we keep it simple and stable by shifting.

contacts.c — queries

/* Linear scan for an id. Returns a pointer INTO the array (do not free
   it) or NULL if absent. See the linear-vs-binary search demo. */
Contact *book_find(Book *b, int id) {
    for (size_t i = 0; i < b->count; i++)
        if (b->items[i].id == id)
            return &b->items[i];
    return NULL;
}

void book_list(const Book *b) {
    if (b->count == 0) { puts("  (no contacts yet)"); return; }
    printf("  %-4s %-22s %-28s %s\n", "ID", "NAME", "EMAIL", "AGE");
    for (size_t i = 0; i < b->count; i++) {
        const Contact *c = &b->items[i];
        printf("  %-4d %-22s %-28s %d\n", c->id, c->name, c->email, c->age);
    }
}

/* Delete by id. Returns 1 if a record was removed, else 0. Closes the
   gap with memmove so the array stays contiguous (no tombstones). */
int book_delete(Book *b, int id) {
    for (size_t i = 0; i < b->count; i++) {
        if (b->items[i].id == id) {
            size_t tail = b->count - i - 1;       /* items after i */
            memmove(&b->items[i], &b->items[i + 1],
                    tail * sizeof(Contact));
            b->count--;
            return 1;
        }
    }
    return 0;
}

The classic beginner bug is mixing scanf("%d") with fgets and leaving a stray newline in the buffer. We avoid it by reading whole lines with fgets and parsing them ourselves. read_line also strips the trailing '\n' and rejects empty input; read_int uses strtol so we can detect non-numeric junk and out-of-range values instead of silently accepting them.

contacts.c — input

/* Read a trimmed, non-empty line into `buf` (size `cap`). Returns 1 on
   success, 0 on EOF. Extra characters beyond the buffer are discarded. */
int read_line(const char *prompt, char *buf, size_t cap) {
    printf("%s", prompt);
    if (fgets(buf, (int)cap, stdin) == NULL) return 0;   /* EOF / error */

    size_t len = strlen(buf);
    if (len > 0 && buf[len - 1] == '\n') {
        buf[len - 1] = '\0';                       /* chop the newline */
    } else {
        int ch;                                    /* line too long: flush rest */
        while ((ch = getchar()) != '\n' && ch != EOF) { }
    }
    return buf[0] != '\0';                        /* reject empty input */
}

/* Read an integer in [lo, hi]. Re-prompts until valid or EOF (-> def). */
int read_int(const char *prompt, int lo, int hi, int def) {
    char buf[LINE_LEN];
    while (read_line(prompt, buf, sizeof buf)) {
        char *end;
        long v = strtol(buf, &end, 10);
        if (end != buf && *end == '\0' && v >= lo && v <= hi)
            return (int)v;
        printf("  please enter a whole number %d..%d\n", lo, hi);
    }
    return def;                                    /* EOF: fall back to default */
}

This is Module 3, Session 8 in action — opening files, checking the FILE* for NULL, and always fclose-ing. We pick a simple line format: one record per line, fields separated by commas. Saving is a straightforward loop; loading rebuilds the store with the same book_add path so growth and ids are handled for free. Note we re-derive next_id so saved ids are not reused.

contacts.c — persistence

/* Write the whole book to `path` as CSV. Returns 1 on success.
   NOTE: this simple format assumes names/emails contain no commas. */
int book_save(const Book *b, const char *path) {
    FILE *f = fopen(path, "w");
    if (f == NULL) { perror(path); return 0; }   /* check the handle! */

    for (size_t i = 0; i < b->count; i++) {
        const Contact *c = &b->items[i];
        fprintf(f, "%d,%s,%s,%d\n", c->id, c->name, c->email, c->age);
    }
    fclose(f);                                    /* release the OS resource */
    return 1;
}

/* Load records from `path` into an already-initialised book. A missing
   file is not an error (first run) — returns 1 with an empty book. */
int book_load(Book *b, const char *path) {
    FILE *f = fopen(path, "r");
    if (f == NULL) return 1;                     /* no file yet: fine */

    char line[LINE_LEN];
    int max_id = 0;
    while (fgets(line, sizeof line, f)) {
        Contact c = {0};
        /* %[^,] reads up to the next comma; widths guard the buffers */
        int n = sscanf(line, "%d,%63[^,],%95[^,],%d",
                       &c.id, c.name, c.email, &c.age);
        if (n == 4) {
            book_reserve(b, b->count + 1);
            b->items[b->count++] = c;
            if (c.id > max_id) max_id = c.id;
        }
    }
    fclose(f);
    b->next_id = max_id + 1;                       /* don't reuse loaded ids */
    return 1;
}

Finally the menu loop: print options, read a choice with the validated read_int, dispatch with a switch, and repeat until the user quits. main owns the single Book on the stack, loads any saved data at start, and — crucially — book_save + book_free on the way out so there are no leaks and the data persists.

contacts.c — ui + main

#define DB_PATH "contacts.csv"

void do_add(Book *b) {
    Contact c = {0};
    if (!read_line("  name : ", c.name,  sizeof c.name))  return;
    if (!read_line("  email: ", c.email, sizeof c.email)) return;
    c.age = read_int("  age  : ", 0, 150, 0);
    int id = book_add(b, c);
    if (id < 0) puts("  could not add (out of memory)");
    else        printf("  added contact #%d\n", id);
}

void do_find(Book *b) {
    int id = read_int("  id to find: ", 1, 1000000, -1);
    Contact *c = book_find(b, id);
    if (c) printf("  #%d  %s <%s>  age %d\n", c->id, c->name, c->email, c->age);
    else   puts("  no contact with that id");
}

void menu(void) {
    puts("\n=== contact manager ===");
    puts("  1) add     2) list    3) find");
    puts("  4) delete  5) save    0) quit");
}

int main(void) {
    Book book;
    book_init(&book);
    book_load(&book, DB_PATH);
    printf("loaded %zu contact(s) from %s\n", book.count, DB_PATH);

    int running = 1;
    while (running) {
        menu();
        int choice = read_int("  > ", 0, 5, 0);
        switch (choice) {
            case 1: do_add(&book); break;
            case 2: book_list(&book); break;
            case 3: do_find(&book); break;
            case 4: {
                int id = read_int("  id to delete: ", 1, 1000000, -1);
                puts(book_delete(&book, id) ? "  deleted" : "  not found");
                break;
            }
            case 5:
                if (book_save(&book, DB_PATH))
                    printf("  saved %zu contact(s)\n", book.count);
                break;
            case 0: running = 0; break;
        }
    }

    book_save(&book, DB_PATH);                     /* persist on exit  */
    book_free(&book);                              /* free the buffer  */
    puts("bye.");
    return 0;
}