Putting it together: a roster

The shape of the program

This program keeps a small roster of students. Each student is a struct with a name and a score. The list is a block of memory from malloc, sized to hold the students you name.

A function walks the list and adds up the scores. The main function owns the memory: it allocates the block, fills it, calls the function, and frees the block at the end.

Where the chapters land

The struct type and its fields come from the structs chapter. The block of students from malloc is the dynamic memory chapter, and the pointer handed to the function is the pointers chapter.

The total function is the functions chapter. It walks the list with a loop from the arrays chapter. Nothing here is new; the capstone is the earlier pieces working in one file.

What a real one adds

Real programs grow the list when it fills, check every return from malloc, and free the memory on every path out, including the error ones. They also copy names carefully, since a struct field is only so much room for text.

Those are additions to the same shape you are about to write, not replacements for it. Once the struct and the block are in place, growth is a bigger request, a copy, and a free.

A roster has a count and a capacity

The list you allocate has a capacity — how many students fit — and a count — how many are filled. They are different numbers, and mixing them is how a program writes past its block. Keep both, and grow only when the count reaches the capacity.

Growth means asking for a bigger block, copying the old values, and releasing the old one. realloc does all three, but it may move the block, so pointers into the old list may become invalid after the call.

Ownership across functions

Decide who owns the block before you write the functions. Here main allocates and frees, while total only borrows. A function that frees memory it did not allocate will surprise its caller, especially if the caller still needs the list.

The same rule covers names inside a struct: a fixed char name[12] is room you own, and copying into it needs a bound. snprintf(student.name, sizeof student.name, "%s", source) stops at the edge of the buffer; strcpy does not.

A worked growth, step by step

Start with room for two and two filled. A third student arrives: the count equals the capacity, so ask for room for four. realloc may return the same address or a new one; either way it preserves the old two entries, and if it moved, the old block has already been released. Then write the third entry and raise the count to three.

The capacity doubles, so the next two arrivals cost nothing. Growing by one on every insert would copy the whole list each time, which turns a linear job into a quadratic one. Doubling trades a little wasted room for a bound on the copying, and it is the same trade a dynamic array makes in every language.

Testing the edges

A roster program has four cases worth running before you trust it: zero students, one student, a count exactly at capacity, and a count one past it. The first checks that the report survives an empty list, and the last forces a growth. A program that only ever sees three students never exercises the branch that moves the block.

Print the count and the capacity after each change, and free the block on every path. The report is the easy part; the value of the capstone is that the ownership stays visible from the first malloc to the last free. If you can point at the line that releases each block, the program is sound.

Try these next

• Add a capacity variable and grow the roster only when count == capacity.
• Write a function that prints one student through a Student *, then call it for every entry.
• Give the name field more room and use snprintf with sizeof to copy a longer name safely.

The pattern in miniature

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

typedef struct {
    int score;
} Entry;

int main(void) {
    Entry *list = malloc(2 * sizeof(Entry));
    list[0].score = 5;
    list[1].score = 7;
    printf("Total %d\n", list[0].score + list[1].score);
    free(list);
    return 0;
}