Contact Book

Create a contact management system with add, delete, search, and update functionality using file handling.

StructuresFile I/OArrays

Overview

A contact book is one of the most natural first "real" projects in C because it forces you to combine four skills you have learned separately into one working program: structures to model a contact, arrays to hold many of them in memory, string handling to search and compare names, and file I/O to make the data survive after the program exits. Nothing you type into a contact book should disappear the moment you close the terminal, and that persistence requirement is exactly what pushes this project beyond a toy exercise.

By the end of this tutorial you will have a menu-driven console application that stores contacts on disk in a binary file, loads them back in on startup, and lets the user add, list, search, update, and delete entries. Every operation you build reinforces how structs, arrays of structs, and fread/fwrite work together in a single, coherent program.

What You'll Build

A Contact struct holding name, phone number, and email.
An "Add Contact" feature that appends a new entry to a binary data file.
A "List Contacts" feature that reads every saved contact and prints them in a formatted table.
A "Search Contact" feature that finds a contact by name.
Update and delete features that rewrite the file with the modified contact list.
A menu loop that keeps the program running until the user chooses to exit.

Prerequisites

Structures — defining a struct, creating variables of that type, and accessing members with the dot operator.
Arrays — declaring fixed-size arrays and looping over them with for.
Strings in C — using char arrays, and functions like strcpy and strcmp from <string.h>.
File handling — opening a file with fopen, checking for NULL, and closing it with fclose.
Functions — passing structs and arrays to functions, and returning values from them.

Project Structure

The whole program lives in a single file, contact_book.c, which is typical for small C console projects. Internally, we will keep the design simple: every contact is a struct Contact with three fields (name, phone, email). Rather than keeping contacts only in memory, we persist them in a binary file named contacts.dat using fwrite to write raw struct Contact records and fread to read them back. Binary I/O is a good fit here because a struct can be written and read as one fixed-size block, with no manual text parsing required.

Each menu operation follows the same general pattern: open contacts.dat in the appropriate mode ("ab" to append, "rb" to read, or "wb" to rewrite), perform the operation, and close the file immediately afterward. Update and delete are slightly different because C files do not support removing a record from the middle directly — instead, we read every contact into a temporary array, apply the change in memory, and rewrite the whole file.

Step 1: Define the Contact Structure

Everything starts with the data model. We define a struct Contact with fixed-size character arrays for the name, phone number, and email, and we introduce a file name constant so it is defined in exactly one place. Fixed-size fields are important for binary file I/O — since we will write the struct directly to disk with fwrite, every record must be exactly the same number of bytes.

#include <stdio.h>   // Gives us printf/scanf and the FILE type for console and file I/O
#include <string.h>  // Gives us strcpy/strcmp, needed later to copy and compare contact names
#include <stdlib.h>  // Standard utility library, included by convention for a self-contained C file

#define FILENAME "contacts.dat"  // One named constant for the data file so every function agrees on it
#define NAME_LEN 50               // Max stored length for a name, including the null terminator
#define PHONE_LEN 15               // Max stored length for a phone number
#define EMAIL_LEN 50               // Max stored length for an email address

// Fixed-size char arrays make every Contact the same number of bytes, which fwrite/fread rely on
typedef struct {
    char name[NAME_LEN];   // Contact's name, stored as a fixed-size buffer
    char phone[PHONE_LEN]; // Contact's phone number, stored as a fixed-size buffer
    char email[EMAIL_LEN]; // Contact's email, stored as a fixed-size buffer
} Contact;

Using typedef struct { ... } Contact; lets us write Contact instead of struct Contact everywhere else in the program, which keeps function signatures shorter and more readable.

Step 2: Add a New Contact

Adding a contact means reading three strings from the user, filling in a Contact variable, and appending it to contacts.dat. We open the file in "ab" (append binary) mode, which creates the file if it does not exist yet and always writes new data after whatever is already there.

void addContact(void) {
    Contact c;                            // Local record we'll fill in and then write to disk
    FILE *fp = fopen(FILENAME, "ab");     // Open in append-binary mode so writing never overwrites earlier contacts
    if (fp == NULL) {                     // fopen returns NULL if the file can't be created/opened
        printf("Error: could not open file for writing.\n");
        return;                           // Bail out early rather than working with a missing file
    }

    printf("Enter name: ");
    scanf(" %49[^\n]", c.name);           // Read up to 49 chars up to newline so names with spaces work
    printf("Enter phone: ");
    scanf(" %14[^\n]", c.phone);          // Cap at 14 chars to match PHONE_LEN's 15-byte buffer
    printf("Enter email: ");
    scanf(" %49[^\n]", c.email);          // Same bounded read, guards against buffer overflow

    fwrite(&c, sizeof(Contact), 1, fp);   // Write exactly one Contact-sized block, taken from &c
    fclose(fp);                           // Flush to disk and release the file handle immediately

    printf("Contact \"%s\" saved successfully!\n", c.name);
}

The %49[^\n] format specifier reads up to 49 characters until it hits a newline, which safely captures names with spaces (unlike plain %s, which stops at the first space) while never overflowing the 50-byte name array. fwrite(&c, sizeof(Contact), 1, fp) writes exactly one block of sizeof(Contact) bytes, taken from the address of c, into the file.

Sample Run of addContact()

Click Run to see what this code prints.

Step 3: List All Contacts

Listing contacts means opening the file in "rb" (read binary) mode and reading one Contact record at a time in a loop until fread reports that there is nothing left to read. fread returns the number of complete records it managed to read, so checking that the return value equals 1 is how we detect end-of-file.

void listContacts(void) {
    Contact c;                          // Reused as scratch space for each record read from disk
    int count = 0;                      // Tracks how many contacts we've printed, doubles as the row number
    FILE *fp = fopen(FILENAME, "rb");   // Open read-only in binary mode since we're only reading records
    if (fp == NULL) {
        printf("No contacts found yet.\n");
        return;                         // No file yet means no contacts have been added
    }

    printf("\n%-4s %-20s %-15s %-25s\n", "No.", "Name", "Phone", "Email");  // Column headers
    printf("---------------------------------------------------------------\n");  // Visual separator under headers

    while (fread(&c, sizeof(Contact), 1, fp) == 1) {  // fread returns 1 while a full record was read; 0 means end of file
        count++;
        printf("%-4d %-20s %-15s %-25s\n", count, c.name, c.phone, c.email);  // Left-aligned columns for a table look
    }

    if (count == 0) {                   // Loop ran zero times, so the file existed but was empty
        printf("No contacts saved yet.\n");
    }

    fclose(fp);                         // Release the file handle now that we're done reading
}

The %-20s style format specifiers left-align each field inside a fixed-width column, which gives the output a clean, table-like appearance without needing any external formatting library.

Step 4: Search for a Contact

Searching reuses the same read loop as listing, but instead of printing every contact, it compares each contact's name against the search term using strcmp and stops as soon as it finds a match. strcmp returns 0 when two strings are exactly equal, which is the condition we check for.

void searchContact(void) {
    char target[NAME_LEN];   // Holds the name the user is searching for
    Contact c;                // Scratch record reused for each entry read from the file
    int found = 0;            // Flag so we can tell after the loop whether a match turned up

    printf("Enter name to search: ");
    scanf(" %49[^\n]", target);   // Same bounded read pattern used for adding contacts

    FILE *fp = fopen(FILENAME, "rb");   // Read-only binary mode, same as listing
    if (fp == NULL) {
        printf("No contacts found yet.\n");
        return;
    }

    while (fread(&c, sizeof(Contact), 1, fp) == 1) {   // Walk every saved record until one matches or file ends
        if (strcmp(c.name, target) == 0) {              // strcmp returns 0 only when the strings are identical
            printf("\nContact found:\n");
            printf("Name : %s\n", c.name);
            printf("Phone: %s\n", c.phone);
            printf("Email: %s\n", c.email);
            found = 1;
            break;                                       // No need to keep scanning once we've found the contact
        }
    }

    fclose(fp);

    if (!found) {   // Only reached if the loop finished without ever setting found
        printf("No contact named \"%s\" was found.\n", target);
    }
}

Step 5: Update a Contact

C's standard file functions cannot edit one record in the middle of a file in place without disturbing the rest, so the safest general approach is: read all contacts into memory, find and modify the matching one, then rewrite the entire file from that in-memory array using "wb" mode (which truncates the existing file before writing). This is simple to reason about and works well for contact-book-sized data sets.

#define MAX_CONTACTS 100  // Upper bound on how many contacts we can hold in memory at once

int loadAllContacts(Contact list[]) {
    FILE *fp = fopen(FILENAME, "rb");   // Read-only binary mode, we're only loading existing data
    int count = 0;                      // Tracks how many records were actually read into list[]
    if (fp == NULL) return 0;           // No file yet means there's nothing to load

    while (count < MAX_CONTACTS && fread(&list[count], sizeof(Contact), 1, fp) == 1) {
        count++;                        // Stops at MAX_CONTACTS so we never write past the array bounds
    }
    fclose(fp);
    return count;                       // Caller needs this to know how many of list[]'s slots are valid
}

void saveAllContacts(Contact list[], int count) {
    FILE *fp = fopen(FILENAME, "wb");   // "wb" truncates the file first, so this fully replaces its contents
    if (fp == NULL) {
        printf("Error: could not open file for writing.\n");
        return;
    }
    fwrite(list, sizeof(Contact), count, fp);   // Writes count contiguous Contact records in one call
    fclose(fp);
}

void updateContact(void) {
    Contact list[MAX_CONTACTS];          // Working copy of every contact, loaded from disk
    char target[NAME_LEN];               // Name of the contact the user wants to update
    int count = loadAllContacts(list);   // Pull the whole file into memory before making changes
    int i, found = 0;

    printf("Enter name to update: ");
    scanf(" %49[^\n]", target);

    for (i = 0; i < count; i++) {
        if (strcmp(list[i].name, target) == 0) {   // Locate the matching contact by name
            printf("Enter new phone: ");
            scanf(" %14[^\n]", list[i].phone);      // Overwrite the phone field in memory only, for now
            printf("Enter new email: ");
            scanf(" %49[^\n]", list[i].email);      // Overwrite the email field the same way
            found = 1;
            break;                                   // No need to keep scanning after the match is updated
        }
    }

    if (found) {
        saveAllContacts(list, count);   // Persist the whole in-memory array, including the one edited record
        printf("Contact \"%s\" updated successfully!\n", target);
    } else {
        printf("No contact named \"%s\" was found.\n", target);
    }
}

Notice that loadAllContacts and saveAllContacts are small, reusable helper functions — both the update and delete features below depend on this same "load into an array, modify, save back" pattern, so writing it once avoids duplicating file-handling code.

Step 6: Delete a Contact

Deleting follows the same load-modify-save pattern as updating, except instead of changing a field we skip copying the matching contact into a second array, effectively removing it before the file is rewritten.

void deleteContact(void) {
    Contact list[MAX_CONTACTS];        // Every contact currently on disk, loaded into memory
    Contact remaining[MAX_CONTACTS];   // Second array we'll build up, skipping the deleted contact
    char target[NAME_LEN];             // Name of the contact to remove
    int count = loadAllContacts(list);
    int i, remainingCount = 0, found = 0;

    printf("Enter name to delete: ");
    scanf(" %49[^\n]", target);

    for (i = 0; i < count; i++) {
        if (strcmp(list[i].name, target) == 0) {
            found = 1;
            continue;                       // Skip copying this one into remaining[], which deletes it
        }
        remaining[remainingCount++] = list[i];   // Keep every other contact, compacting the array as we go
    }

    if (found) {
        saveAllContacts(remaining, remainingCount);   // Rewrite the file with the shorter, filtered list
        printf("Contact \"%s\" deleted successfully!\n", target);
    } else {
        printf("No contact named \"%s\" was found.\n", target);
    }
}

Step 7: Build the Menu Loop

Finally, main ties every feature together behind a numbered menu that keeps looping until the user chooses to exit. Reading the menu choice with scanf("%d", &choice) and using a switch statement is a standard, beginner-friendly way to drive a console application like this.

int main(void) {
    int choice;   // Holds the menu option the user typed

    do {          // do-while so the menu shows at least once before checking the exit condition
        printf("\n===== CONTACT BOOK =====\n");
        printf("1. Add Contact\n");
        printf("2. List Contacts\n");
        printf("3. Search Contact\n");
        printf("4. Update Contact\n");
        printf("5. Delete Contact\n");
        printf("6. Exit\n");
        printf("Enter your choice: ");
        scanf("%d", &choice);

        switch (choice) {   // Dispatch to the matching feature based on the number typed
            case 1: addContact(); break;
            case 2: listContacts(); break;
            case 3: searchContact(); break;
            case 4: updateContact(); break;
            case 5: deleteContact(); break;
            case 6: printf("Goodbye!\n"); break;
            default: printf("Invalid choice, try again.\n");   // Catches any number outside 1-6
        }
    } while (choice != 6);   // Keep looping until the user explicitly picks Exit

    return 0;   // Successful program termination
}

Complete Code

Here is the full program with every function assembled in the correct order, ready to compile with gcc contact_book.c -o contact_book.

#include <stdio.h>   // printf/scanf and the FILE type for console and file I/O
#include <string.h>  // strcpy/strcmp for copying and comparing contact names
#include <stdlib.h>  // Standard utility library, included by convention

#define FILENAME "contacts.dat"  // Single named constant for the data file, used by every function
#define NAME_LEN 50               // Max stored length for a name
#define PHONE_LEN 15               // Max stored length for a phone number
#define EMAIL_LEN 50               // Max stored length for an email address
#define MAX_CONTACTS 100           // Upper bound on contacts held in memory at once for update/delete

// Fixed-size fields let a Contact be written/read as one raw block via fwrite/fread
typedef struct {
    char name[NAME_LEN];   // Contact's name
    char phone[PHONE_LEN]; // Contact's phone number
    char email[EMAIL_LEN]; // Contact's email
} Contact;

void addContact(void) {
    Contact c;                            // Local record we'll fill in and then write to disk
    FILE *fp = fopen(FILENAME, "ab");     // Open in append-binary mode so writing never overwrites earlier contacts
    if (fp == NULL) {                     // fopen returns NULL if the file can't be created/opened
        printf("Error: could not open file for writing.\n");
        return;                           // Bail out early rather than working with a missing file
    }

    printf("Enter name: ");
    scanf(" %49[^\n]", c.name);           // Read up to 49 chars up to newline so names with spaces work
    printf("Enter phone: ");
    scanf(" %14[^\n]", c.phone);          // Cap at 14 chars to match PHONE_LEN's 15-byte buffer
    printf("Enter email: ");
    scanf(" %49[^\n]", c.email);          // Same bounded read, guards against buffer overflow

    fwrite(&c, sizeof(Contact), 1, fp);   // Write exactly one Contact-sized block, taken from &c
    fclose(fp);                           // Flush to disk and release the file handle immediately

    printf("Contact \"%s\" saved successfully!\n", c.name);
}

void listContacts(void) {
    Contact c;                          // Reused as scratch space for each record read from disk
    int count = 0;                      // Tracks how many contacts we've printed, doubles as the row number
    FILE *fp = fopen(FILENAME, "rb");   // Open read-only in binary mode since we're only reading records
    if (fp == NULL) {
        printf("No contacts found yet.\n");
        return;                         // No file yet means no contacts have been added
    }

    printf("\n%-4s %-20s %-15s %-25s\n", "No.", "Name", "Phone", "Email");  // Column headers
    printf("---------------------------------------------------------------\n");  // Visual separator under headers

    while (fread(&c, sizeof(Contact), 1, fp) == 1) {  // fread returns 1 while a full record was read; 0 means end of file
        count++;
        printf("%-4d %-20s %-15s %-25s\n", count, c.name, c.phone, c.email);  // Left-aligned columns for a table look
    }

    if (count == 0) {                   // Loop ran zero times, so the file existed but was empty
        printf("No contacts saved yet.\n");
    }

    fclose(fp);                         // Release the file handle now that we're done reading
}

void searchContact(void) {
    char target[NAME_LEN];   // Holds the name the user is searching for
    Contact c;                // Scratch record reused for each entry read from the file
    int found = 0;            // Flag so we can tell after the loop whether a match turned up

    printf("Enter name to search: ");
    scanf(" %49[^\n]", target);   // Same bounded read pattern used for adding contacts

    FILE *fp = fopen(FILENAME, "rb");   // Read-only binary mode, same as listing
    if (fp == NULL) {
        printf("No contacts found yet.\n");
        return;
    }

    while (fread(&c, sizeof(Contact), 1, fp) == 1) {   // Walk every saved record until one matches or file ends
        if (strcmp(c.name, target) == 0) {              // strcmp returns 0 only when the strings are identical
            printf("\nContact found:\n");
            printf("Name : %s\n", c.name);
            printf("Phone: %s\n", c.phone);
            printf("Email: %s\n", c.email);
            found = 1;
            break;                                       // No need to keep scanning once we've found the contact
        }
    }

    fclose(fp);

    if (!found) {   // Only reached if the loop finished without ever setting found
        printf("No contact named \"%s\" was found.\n", target);
    }
}

int loadAllContacts(Contact list[]) {
    FILE *fp = fopen(FILENAME, "rb");   // Read-only, we're just loading what's already saved
    int count = 0;                      // Number of records successfully read
    if (fp == NULL) return 0;           // No file yet, so nothing to load

    while (count < MAX_CONTACTS && fread(&list[count], sizeof(Contact), 1, fp) == 1) {
        count++;                        // Bounded by MAX_CONTACTS to avoid overrunning list[]
    }
    fclose(fp);
    return count;                       // Tells the caller how many entries in list[] are valid
}

void saveAllContacts(Contact list[], int count) {
    FILE *fp = fopen(FILENAME, "wb");   // "wb" truncates the file so this fully rewrites it
    if (fp == NULL) {
        printf("Error: could not open file for writing.\n");
        return;
    }
    fwrite(list, sizeof(Contact), count, fp);   // Write all count records back in one contiguous block
    fclose(fp);
}

void updateContact(void) {
    Contact list[MAX_CONTACTS];          // Working copy of every saved contact
    char target[NAME_LEN];               // Name to search for
    int count = loadAllContacts(list);   // Load everything before editing anything
    int i, found = 0;

    printf("Enter name to update: ");
    scanf(" %49[^\n]", target);

    for (i = 0; i < count; i++) {
        if (strcmp(list[i].name, target) == 0) {   // Found the contact to edit
            printf("Enter new phone: ");
            scanf(" %14[^\n]", list[i].phone);      // Update in memory first
            printf("Enter new email: ");
            scanf(" %49[^\n]", list[i].email);
            found = 1;
            break;
        }
    }

    if (found) {
        saveAllContacts(list, count);   // Write the whole updated array back to disk
        printf("Contact \"%s\" updated successfully!\n", target);
    } else {
        printf("No contact named \"%s\" was found.\n", target);
    }
}

void deleteContact(void) {
    Contact list[MAX_CONTACTS];        // Every contact currently on disk, loaded into memory
    Contact remaining[MAX_CONTACTS];   // Second array we'll build up, skipping the deleted contact
    char target[NAME_LEN];             // Name of the contact to remove
    int count = loadAllContacts(list);
    int i, remainingCount = 0, found = 0;

    printf("Enter name to delete: ");
    scanf(" %49[^\n]", target);

    for (i = 0; i < count; i++) {
        if (strcmp(list[i].name, target) == 0) {
            found = 1;
            continue;                       // Skip copying this one into remaining[], which deletes it
        }
        remaining[remainingCount++] = list[i];   // Keep every other contact, compacting the array as we go
    }

    if (found) {
        saveAllContacts(remaining, remainingCount);   // Rewrite the file with the shorter, filtered list
        printf("Contact \"%s\" deleted successfully!\n", target);
    } else {
        printf("No contact named \"%s\" was found.\n", target);
    }
}

int main(void) {
    int choice;   // Holds the menu option the user typed

    do {          // do-while so the menu shows at least once before checking the exit condition
        printf("\n===== CONTACT BOOK =====\n");
        printf("1. Add Contact\n");
        printf("2. List Contacts\n");
        printf("3. Search Contact\n");
        printf("4. Update Contact\n");
        printf("5. Delete Contact\n");
        printf("6. Exit\n");
        printf("Enter your choice: ");
        scanf("%d", &choice);

        switch (choice) {   // Dispatch to the matching feature based on the number typed
            case 1: addContact(); break;
            case 2: listContacts(); break;
            case 3: searchContact(); break;
            case 4: updateContact(); break;
            case 5: deleteContact(); break;
            case 6: printf("Goodbye!\n"); break;
            default: printf("Invalid choice, try again.\n");   // Catches any number outside 1-6
        }
    } while (choice != 6);   // Keep looping until the user explicitly picks Exit

    return 0;   // Successful program termination
}

Sample Run

Click Run to see what this code prints.

Extend This Project

Prevent duplicate contacts by checking whether the entered name already exists before calling addContact.
Sort the contact list alphabetically before printing, using qsort with a custom comparator on the name field.
Add a "search by partial name" mode using strstr instead of requiring an exact strcmp match.
Encrypt the phone and email fields with a simple XOR cipher before writing them to disk, and decrypt on read.
Replace the fixed MAX_CONTACTS array with dynamic memory (malloc/realloc) so the contact book has no hard upper limit.

Summary

You built a complete, persistent Contact Book in C, combining a struct-based data model, array-based in-memory processing, and binary file I/O into one cohesive application. The load-modify-save pattern you used for updating and deleting is a technique you will reach for constantly in future C projects any time you need to change one record inside a flat file.