How Do Lab 8 Project and Generic Programming Fit Together?

After this lesson, you will be able to:

• Describe the three-layer architecture (driver, generic container, type-specific callbacks)
• Implement buildTypeWord to read, allocate, and return data as void *
• Implement cleanTypeWord to free nested allocations in the correct order
• Allocate strlen + 1 bytes for strings and explain the buffer overflow without +1

Connecting the Pieces

You’ve learned function pointers, void pointers, and the generic container pattern. Lab 8 asks you to implement this pattern: write type-specific callbacks for a Word struct that plug into a provided generic array.

This lesson walks through the implementation strategy — what to write first, how to test, and where the tricky memory management lives.

The Lab 8 Architecture

Three Layers

┌─────────────────────────┐
│   main.c (driver)       │ ← Reads file, calls generic functions
├─────────────────────────┤
│   genericArray.c        │ ← Generic container (provided)
│   Uses void * + callbacks│
├─────────────────────────┤
│   words.c               │ ← YOUR callbacks: build, print, compare, clean
│   Works with Word struct │
└─────────────────────────┘

The generic layer calls your functions through function pointers. You never modify the generic code — you just plug in callbacks.

The Word Struct

typedef struct
{
    char *letters;    // Dynamically allocated string
    int length;
} Word;

Two heap allocations per word: one for the struct, one for the string.

The Five Callbacks

1. printTypeWord — easiest, start here:

void printTypeWord(void *data)
{
    if (data == NULL) return;
    Word *w = (Word *)data;
    printf("%s", w->letters);
}

2. compareWords — string comparison:

int compareWords(void *a, void *b)
{
    if (a == NULL || b == NULL) return 0;
    Word *wa = (Word *)a;
    Word *wb = (Word *)b;
    return strcmp(wa->letters, wb->letters);
}

3. cleanTypeWord — free inner then outer:

void cleanTypeWord(void *data)
{
    if (data == NULL) return;
    Word *w = (Word *)data;
    free(w->letters);     // Free string first
    free(w);              // Then free struct
}

4. buildTypeWord — read from file, allocate everything:

void *buildTypeWord(FILE *fp)
{
    char buffer[256];
    if (fgets(buffer, sizeof(buffer), fp) == NULL)
    {
        return NULL;
    }
    buffer[strcspn(buffer, "\n")] = '\0';

    Word *w = calloc(1, sizeof(Word));
    if (w == NULL) return NULL;

    w->length = strlen(buffer);
    w->letters = calloc(w->length + 1, sizeof(char));
    if (w->letters == NULL)
    {
        free(w);
        return NULL;
    }
    strcpy(w->letters, buffer);

    return (void *)w;
}

5. buildTypeWord_Prompt — same but reads from stdin with a prompt.

Implementation Strategy

The Trick: Implement functions in order of difficulty, test after each one:

1. printTypeWord — just cast and printf
2. compareWords — cast and strcmp
3. cleanTypeWord — two frees in the right order
4. buildTypeWord — the hardest: read, allocate struct, allocate string, copy
5. buildTypeWord_Prompt — variation of build

Get each one compiling and tested before moving to the next. Run Valgrind after implementing clean to verify no leaks.

Memory for One Word

Heap:
┌──────────────┐
│ Word struct   │
│  letters ──────────→ ┌─────────────┐
│  length = 5  │       │ "hello\0"   │
└──────────────┘       └─────────────┘
  (calloc #1)            (calloc #2)

Two allocations → two frees. cleanTypeWord must free both.

Common Mistakes

==12345== HEAP SUMMARY:
==12345==     in use at exit: 0 bytes in 0 blocks
==12345==   total heap usage: 11 allocs, 11 frees, ...

Series 4 Complete

You’ve gone from basic structs through file I/O, sorting, function pointers, void pointers, generic containers, and linked lists. These are the tools used to build real data structures — hash tables, trees, graphs — in later courses.

In the final series, Systems Programming, you’ll learn fork, exec, pipe, and signal — connecting everything back to Unix. The C programs you write will create other processes, just like the shell does when you type a command.

The CTF Challenges for Weeks 8–9 include struct, file I/O, and function pointer challenges that test the patterns you’ve just learned.

Big Picture: The generic container pattern — void pointers + function pointer callbacks — is how C libraries achieve type-independent behavior. It’s the same approach used in the Linux kernel, database engines, and language runtimes. Java generics and interfaces are a safer, more ergonomic version of the same idea. Understanding the C version means understanding what those higher-level abstractions actually do.