Banking System

Develop a simple banking application with account creation, deposit, withdrawal, and balance inquiry.

PointersFunctionsFile Handling

Overview

A banking system is an excellent project for practicing pointers because it has a natural reason to use them: every operation on an account (deposit, withdrawal, balance check) needs to change or read the actual account data, not a disposable copy of it. Passing a struct Account * into a function and modifying acc->balance directly is the idiomatic C way to do this, and it mirrors exactly how larger real-world systems pass records around by reference instead of copying them everywhere.

This tutorial builds a console banking application that stores multiple accounts in an array, lets the user create accounts, deposit and withdraw money with validation, check balances, and persist every account to a file so the bank's data survives between runs.

What You'll Build

An Account struct holding an account number, holder name, and balance.
Account creation that assigns a new, unique account number automatically.
A deposit function that modifies the balance through a pointer to the account.
A withdrawal function that validates the amount and rejects overdrafts.
A balance inquiry feature that looks up an account by number.
File handling that saves all accounts to disk and reloads them on startup.

Prerequisites

Structures — defining and using a struct to group related fields.
Pointers — the & address-of operator, the -> member-access operator on struct pointers, and passing pointers to functions.
Functions — writing functions that take parameters by pointer so they can modify the caller's data.
File handling — reading and writing structured data with fopen, fwrite, fread, and fclose.
Basic validation logic — using if statements to reject invalid input before it changes program state.

Project Structure

All accounts live in a single array, Account accounts[MAX_ACCOUNTS], tracked alongside an accountCount variable that records how many slots are currently in use. Every function that needs to change an account's data — deposit, withdraw — takes an Account *acc parameter, so it operates directly on the account stored in the array rather than a copy. Lookup functions like findAccount return a pointer into the array (or NULL if nothing matches), which the calling code then passes straight into deposit or withdraw.

Persistence works the same way as the Contact Book project: the entire accounts array is written to accounts.dat in one fwrite call whenever the data changes, and read back with one fread call at startup. Because Account has fixed-size fields, the whole array can be treated as one contiguous block of bytes for binary I/O.

Step 1: Define the Account Structure

Each account needs an account number to identify it, a holder name, and a balance. We also declare the global-ish array and count that every other function will operate on.

#include <stdio.h>   // printf/scanf and FILE for console and file I/O
#include <string.h>  // String helpers used elsewhere in the program
#include <stdlib.h>  // Standard utility library, included by convention

#define FILENAME "accounts.dat"   // Single named constant for the data file, used by save/load
#define MAX_ACCOUNTS 100            // Upper bound on how many accounts the bank can hold
#define NAME_LEN 50                 // Max stored length for an account holder's name

typedef struct {
    int accountNumber;         // Unique identifier assigned automatically at creation time
    char holderName[NAME_LEN]; // Fixed-size buffer so the whole struct has a predictable byte size
    double balance;             // Current balance, floating-point to support cents
} Account;

Account accounts[MAX_ACCOUNTS];   // All accounts live in this one array for the program's lifetime
int accountCount = 0;              // How many of accounts[]'s slots are currently in use

Step 2: Create a New Account

Creating an account means reading the holder's name and an initial deposit, assigning the next available account number (starting at 1001), storing the new Account in the array, and incrementing accountCount. Choosing the account number ourselves — rather than asking the user for one — guarantees every account number is unique.

void createAccount(void) {
    if (accountCount >= MAX_ACCOUNTS) {   // Guard against writing past the end of accounts[]
        printf("Cannot create more accounts, bank is full.\n");
        return;
    }

    Account *acc = &accounts[accountCount];   // Point at the next free slot so we can build it up via acc->
    acc->accountNumber = 1001 + accountCount;  // Deriving the number from the count guarantees uniqueness

    printf("Enter account holder name: ");
    scanf(" %49[^\n]", acc->holderName);

    printf("Enter initial deposit amount: ");
    scanf("%lf", &acc->balance);   // %lf reads a double directly into the balance field

    if (acc->balance < 0) {   // Defend against a negative starting balance from bad input
        printf("Initial deposit cannot be negative. Setting balance to 0.\n");
        acc->balance = 0;
    }

    printf("Account created! Your account number is %d.\n", acc->accountNumber);
    accountCount++;   // Only now, after the account is fully populated, mark the slot as used
}

Account *acc = &accounts[accountCount]; takes the address of the next free slot in the array and stores it in a pointer, so every following line uses acc->field instead of the longer accounts[accountCount].field. This is a common C idiom: point at the thing you are about to build up, then work through the pointer.

Sample Run of createAccount()

Click Run to see what this code prints.

Step 3: Deposit Funds Through a Pointer

The deposit function is where pointers earn their keep: it takes an Account *acc and an amount, validates the amount, and updates acc->balance directly. Because acc is a pointer to the actual struct sitting inside the accounts array, this change is visible everywhere else in the program immediately — there is no copy to keep in sync.

void deposit(Account *acc, double amount) {   // Pointer means changes are visible on the original account
    if (amount <= 0) {   // Reject zero or negative deposits before touching the balance
        printf("Deposit amount must be positive.\n");
        return;
    }

    acc->balance += amount;   // Modifies the real account in the accounts[] array, not a copy
    printf("Deposited %.2f. New balance: %.2f\n", amount, acc->balance);
}

Step 4: Withdraw Funds With Validation

Withdrawal follows the same pointer pattern as deposit, but adds a second validation rule: the account must have enough balance to cover the withdrawal. Rejecting an overdraft before touching acc->balance keeps the account in a consistent state even when the user requests an invalid amount.

void withdraw(Account *acc, double amount) {
    if (amount <= 0) {   // Reject zero or negative withdrawal amounts
        printf("Withdrawal amount must be positive.\n");
        return;
    }
    if (amount > acc->balance) {   // Reject overdrafts before the balance is ever changed
        printf("Insufficient funds. Current balance: %.2f\n", acc->balance);
        return;
    }

    acc->balance -= amount;   // Both validations passed, safe to subtract
    printf("Withdrew %.2f. New balance: %.2f\n", amount, acc->balance);
}

Step 5: Check Balance and Find an Account

findAccount searches the array for a matching account number and returns a pointer to it, or NULL if no account matches. Returning a pointer (instead of copying the whole struct out) means the caller can use that same pointer to deposit or withdraw immediately, without searching the array a second time.

Account* findAccount(int accNum) {   // Returns a pointer into the array so callers can modify the account directly
    int i;
    for (i = 0; i < accountCount; i++) {
        if (accounts[i].accountNumber == accNum) {
            return &accounts[i];   // Found it: hand back its address, not a copy
        }
    }
    return NULL;   // No match; callers must check for this before dereferencing
}

void checkBalance(Account *acc) {
    printf("Account #%d (%s) - Balance: %.2f\n",
           acc->accountNumber, acc->holderName, acc->balance);
}

Step 6: Persist Accounts to File

Saving writes the entire accounts array to disk in one fwrite call; loading reads it back in one fread call at program startup, restoring both the account data and accountCount. Because fread returns the number of elements it successfully read, we use that value directly as the new accountCount.

void saveAccounts(void) {
    FILE *fp = fopen(FILENAME, "wb");   // "wb" truncates, so this always writes the current full state
    if (fp == NULL) {
        printf("Error: could not save accounts.\n");
        return;
    }
    fwrite(accounts, sizeof(Account), accountCount, fp);   // Whole array written as one contiguous block
    fclose(fp);
}

void loadAccounts(void) {
    FILE *fp = fopen(FILENAME, "rb");
    if (fp == NULL) {
        accountCount = 0;   // No file yet, so start with an empty bank rather than crashing
        return;
    }
    accountCount = (int)fread(accounts, sizeof(Account), MAX_ACCOUNTS, fp);   // fread's return value is exactly how many accounts existed
    fclose(fp);
}

Step 7: Build the Menu Loop

The menu loop loads existing accounts on startup, offers the usual numbered options, looks up the target account by number for deposit/withdraw/balance operations, and saves the account list back to disk after every change so no data is lost even if the program is closed unexpectedly.

int main(void) {
    int choice, accNum;   // Menu selection and the account number typed for lookups
    double amount;         // Deposit or withdrawal amount typed by the user
    Account *acc;          // Result of findAccount(), reused across the deposit/withdraw/balance cases

    loadAccounts();   // Restore whatever accounts were saved from a previous run

    do {
        printf("\n===== BANKING SYSTEM =====\n");
        printf("1. Create Account\n");
        printf("2. Deposit\n");
        printf("3. Withdraw\n");
        printf("4. Check Balance\n");
        printf("5. Exit\n");
        printf("Enter your choice: ");
        scanf("%d", &choice);

        switch (choice) {
            case 1:
                createAccount();
                saveAccounts();   // Persist immediately so a new account survives an unexpected exit
                break;
            case 2:
                printf("Enter account number: ");
                scanf("%d", &accNum);
                acc = findAccount(accNum);   // Look up once, reuse the pointer below
                if (acc == NULL) {
                    printf("Account not found.\n");
                } else {
                    printf("Enter deposit amount: ");
                    scanf("%lf", &amount);
                    deposit(acc, amount);   // Modifies the account in place through the pointer
                    saveAccounts();          // Save right after the change so nothing is lost
                }
                break;
            case 3:
                printf("Enter account number: ");
                scanf("%d", &accNum);
                acc = findAccount(accNum);
                if (acc == NULL) {
                    printf("Account not found.\n");
                } else {
                    printf("Enter withdrawal amount: ");
                    scanf("%lf", &amount);
                    withdraw(acc, amount);
                    saveAccounts();
                }
                break;
            case 4:
                printf("Enter account number: ");
                scanf("%d", &accNum);
                acc = findAccount(accNum);
                if (acc == NULL) {
                    printf("Account not found.\n");
                } else {
                    checkBalance(acc);   // Read-only, so no save is needed here
                }
                break;
            case 5:
                printf("Goodbye!\n");
                break;
            default:
                printf("Invalid choice, try again.\n");   // Catches anything outside 1-5
        }
    } while (choice != 5);   // Loop until the user explicitly chooses Exit

    return 0;
}

Complete Code

Here is the full program, ready to compile with gcc banking.c -o banking.

#include <stdio.h>   // printf/scanf and FILE for console and file I/O
#include <string.h>  // String helpers used elsewhere in the program
#include <stdlib.h>  // Standard utility library, included by convention

#define FILENAME "accounts.dat"   // Single named constant for the data file, used by save/load
#define MAX_ACCOUNTS 100            // Upper bound on how many accounts the bank can hold
#define NAME_LEN 50                 // Max stored length for an account holder's name

typedef struct {
    int accountNumber;         // Unique identifier assigned automatically at creation time
    char holderName[NAME_LEN]; // Fixed-size buffer so the whole struct has a predictable byte size
    double balance;             // Current balance, floating-point to support cents
} Account;

Account accounts[MAX_ACCOUNTS];   // All accounts live in this one array for the program's lifetime
int accountCount = 0;              // How many of accounts[]'s slots are currently in use

void createAccount(void) {
    if (accountCount >= MAX_ACCOUNTS) {   // Guard against writing past the end of accounts[]
        printf("Cannot create more accounts, bank is full.\n");
        return;
    }

    Account *acc = &accounts[accountCount];   // Point at the next free slot so we can build it up via acc->
    acc->accountNumber = 1001 + accountCount;  // Deriving the number from the count guarantees uniqueness

    printf("Enter account holder name: ");
    scanf(" %49[^\n]", acc->holderName);

    printf("Enter initial deposit amount: ");
    scanf("%lf", &acc->balance);   // %lf reads a double directly into the balance field

    if (acc->balance < 0) {   // Defend against a negative starting balance from bad input
        printf("Initial deposit cannot be negative. Setting balance to 0.\n");
        acc->balance = 0;
    }

    printf("Account created! Your account number is %d.\n", acc->accountNumber);
    accountCount++;   // Only now, after the account is fully populated, mark the slot as used
}

void deposit(Account *acc, double amount) {   // Pointer means changes are visible on the original account
    if (amount <= 0) {   // Reject zero or negative deposits before touching the balance
        printf("Deposit amount must be positive.\n");
        return;
    }

    acc->balance += amount;   // Modifies the real account in the accounts[] array, not a copy
    printf("Deposited %.2f. New balance: %.2f\n", amount, acc->balance);
}

void withdraw(Account *acc, double amount) {
    if (amount <= 0) {   // Reject zero or negative withdrawal amounts
        printf("Withdrawal amount must be positive.\n");
        return;
    }
    if (amount > acc->balance) {   // Reject overdrafts before the balance is ever changed
        printf("Insufficient funds. Current balance: %.2f\n", acc->balance);
        return;
    }

    acc->balance -= amount;   // Both validations passed, safe to subtract
    printf("Withdrew %.2f. New balance: %.2f\n", amount, acc->balance);
}

Account* findAccount(int accNum) {   // Returns a pointer into the array so callers can modify the account directly
    int i;
    for (i = 0; i < accountCount; i++) {
        if (accounts[i].accountNumber == accNum) {
            return &accounts[i];   // Found it: hand back its address, not a copy
        }
    }
    return NULL;   // No match; callers must check for this before dereferencing
}

void checkBalance(Account *acc) {
    printf("Account #%d (%s) - Balance: %.2f\n",
           acc->accountNumber, acc->holderName, acc->balance);
}

void saveAccounts(void) {
    FILE *fp = fopen(FILENAME, "wb");   // "wb" truncates, so this always writes the current full state
    if (fp == NULL) {
        printf("Error: could not save accounts.\n");
        return;
    }
    fwrite(accounts, sizeof(Account), accountCount, fp);   // Whole array written as one contiguous block
    fclose(fp);
}

void loadAccounts(void) {
    FILE *fp = fopen(FILENAME, "rb");
    if (fp == NULL) {
        accountCount = 0;   // No file yet, so start with an empty bank rather than crashing
        return;
    }
    accountCount = (int)fread(accounts, sizeof(Account), MAX_ACCOUNTS, fp);   // fread's return value is exactly how many accounts existed
    fclose(fp);
}

int main(void) {
    int choice, accNum;   // Menu selection and the account number typed for lookups
    double amount;         // Deposit or withdrawal amount typed by the user
    Account *acc;          // Result of findAccount(), reused across the deposit/withdraw/balance cases

    loadAccounts();   // Restore whatever accounts were saved from a previous run

    do {
        printf("\n===== BANKING SYSTEM =====\n");
        printf("1. Create Account\n");
        printf("2. Deposit\n");
        printf("3. Withdraw\n");
        printf("4. Check Balance\n");
        printf("5. Exit\n");
        printf("Enter your choice: ");
        scanf("%d", &choice);

        switch (choice) {
            case 1:
                createAccount();
                saveAccounts();   // Persist immediately so a new account survives an unexpected exit
                break;
            case 2:
                printf("Enter account number: ");
                scanf("%d", &accNum);
                acc = findAccount(accNum);   // Look up once, reuse the pointer below
                if (acc == NULL) {
                    printf("Account not found.\n");
                } else {
                    printf("Enter deposit amount: ");
                    scanf("%lf", &amount);
                    deposit(acc, amount);   // Modifies the account in place through the pointer
                    saveAccounts();          // Save right after the change so nothing is lost
                }
                break;
            case 3:
                printf("Enter account number: ");
                scanf("%d", &accNum);
                acc = findAccount(accNum);
                if (acc == NULL) {
                    printf("Account not found.\n");
                } else {
                    printf("Enter withdrawal amount: ");
                    scanf("%lf", &amount);
                    withdraw(acc, amount);
                    saveAccounts();
                }
                break;
            case 4:
                printf("Enter account number: ");
                scanf("%d", &accNum);
                acc = findAccount(accNum);
                if (acc == NULL) {
                    printf("Account not found.\n");
                } else {
                    checkBalance(acc);   // Read-only, so no save is needed here
                }
                break;
            case 5:
                printf("Goodbye!\n");
                break;
            default:
                printf("Invalid choice, try again.\n");   // Catches anything outside 1-5
        }
    } while (choice != 5);   // Loop until the user explicitly chooses Exit

    return 0;
}

Sample Run

Click Run to see what this code prints.

Extend This Project

Add a PIN field to Account and require it to match before any deposit, withdrawal, or balance check succeeds.
Write a transferFunds(Account *from, Account *to, double amount) function that withdraws from one account and deposits into another atomically.
Log every transaction (type, amount, resulting balance, timestamp) to a separate transactions.dat file for an auditable history.
Add an interest calculation feature that applies a fixed annual interest rate to every account's balance when the user selects a "Run Interest Cycle" menu option.
Introduce account types (Savings vs. Checking) with different withdrawal rules, such as a minimum balance requirement for Savings accounts.

Summary

You built a working banking system that uses pointers the way real C programs do: passing Account * into functions so they can read and modify the actual account data in place, backed by binary file persistence so no transaction is lost between runs. The pattern of "find a pointer to the record, then operate on it through that pointer" is one of the most common and useful idioms in C, and you now have hands-on practice applying it.