Bank Management System

Build an account system with deposits, withdrawals, and transaction history using classes and file handling.

ClassesFile I/OEncapsulation

Overview

A bank management system is one of the clearest ways to see why C++ classes exist in the first place. An account is not just a bundle of data — it is data that must never be changed except through a small set of controlled operations, because a balance that anyone could edit directly would make overdraft checks and transaction history meaningless. That is exactly what encapsulation gives you: the balance field lives inside Account, marked private, and the only way to change it from outside the class is by calling deposit() or withdraw(), both of which validate the amount before touching anything.

By the end of this tutorial you will have a console banking application built around an Account class and a Bank class that manages many accounts at once, complete with per-account transaction history and file persistence using <fstream> so account data survives between runs. Along the way you will see the C++ idiom of declaring methods inside a class and defining their bodies afterward with the ClassName::methodName scope resolution syntax, which is exactly how larger real-world C++ programs are organized.

What You'll Build

An Account class with private accountNumber, holderName, and balance fields.
A deposit() and withdraw() method pair that validate amounts before changing the balance.
A per-account transaction history stored in a std::vector<std::string> and printable on demand.
A Bank class that owns a std::vector<Account> and assigns unique account numbers automatically.
File persistence using std::ofstream/std::ifstream so accounts survive between program runs.
A menu loop tying account creation, deposits, withdrawals, and balance/history lookups together.

Prerequisites

Classes — defining a class with private/public sections, member functions, and constructors.
Encapsulation — why data is kept private and only exposed through controlled public methods.
The Standard Library basics — std::string, std::vector, and range-based for loops.
File handling in C++ — opening files with std::ofstream/std::ifstream and reading lines with std::getline.
Functions — declaring a method inside a class and defining it afterward with ClassName::methodName(...).

Project Structure

The whole program lives in a single file, bank.cpp. Two classes do all the work: Account models one bank account and enforces its own rules (no negative deposits, no overdrafts), and Bank owns a std::vector<Account> representing every account currently open, plus the logic for creating new accounts and finding an existing one by number. Rather than repeating class bodies at every step, each class is declared once with its methods listed but not yet defined, and later steps fill in the method bodies one at a time using the Account::methodName and Bank::methodName syntax — the same declare-then-define split real C++ header/source files use, just kept in one file for simplicity.

Persistence uses plain comma-separated text, not raw binary structs like a C program might use. That is a deliberate choice: Account contains a std::string and a std::vector<std::string>, and neither type can be safely written to disk with a raw byte copy, since both manage memory behind the scenes. Writing "accountNumber,holderName,balance" as one text line per account, and parsing it back with std::stringstream, is the idiomatic C++ way to persist objects that contain strings or containers.

Step 1: Define the Account Class

We start with the includes, a small formatMoney helper that turns a double into a fixed two-decimal string (so 1500 prints as 1500.00 instead of a long floating-point tail), and the Account class itself. The private section holds the data that must stay protected; the public section lists every operation callers are allowed to perform, with only the trivial one-line accessors defined inline and the rest left as declarations to be defined in the next two steps.

#include <iostream>   // std::cin/std::cout for all console interaction
#include <fstream>    // std::ifstream/std::ofstream for reading and writing account data to disk
#include <sstream>    // std::stringstream/std::ostringstream for parsing and formatting text
#include <iomanip>    // std::fixed/std::setprecision for two-decimal money formatting
#include <string>     // std::string and std::to_string/std::stoi/std::stod
#include <vector>     // std::vector to hold each account's transaction history and the bank's accounts

// Formats a monetary amount as a fixed two-decimal string, e.g. 1500 -> "1500.00"
std::string formatMoney(double amount) {
    std::ostringstream oss;                              // Builds the formatted text in memory before returning it
    oss << std::fixed << std::setprecision(2) << amount;  // Force exactly two digits after the decimal point
    return oss.str();                                     // Extract the finished string from the stream
}

class Account {
private:
    int accountNumber;                  // Unique ID assigned by the Bank when the account is created
    std::string holderName;             // Account holder's name
    double balance;                     // Current balance; private so it can only change via deposit()/withdraw()
    std::vector<std::string> history;   // Log of every transaction made on this account

public:
    Account(int accNum, const std::string &name, double startingBalance);   // Declared here, defined in Step 2

    int getAccountNumber() const { return accountNumber; }    // Trivial accessors are fine to define inline
    std::string getHolderName() const { return holderName; }  // Read-only view of the holder's name
    double getBalance() const { return balance; }              // The only way outside code can read the balance

    void deposit(double amount);     // Declared now, defined in Step 3
    void withdraw(double amount);    // Declared now, defined in Step 3
    void printHistory() const;       // Declared now, defined in Step 3
};

Notice that deposit, withdraw, and printHistory appear only as declarations here — a return type, name, and parameter list ending in a semicolon, with no { } body. The compiler now knows these methods exist and what they look like, which is enough to compile code that calls them; the actual bodies are supplied later using Account::deposit(...), and the linker matches them up by name.

Step 2: Build the Account Constructor

The constructor uses a member initializer list — the : accountNumber(accNum), holderName(name), balance(startingBalance) part — which runs before the constructor's body and is the preferred C++ way to set a member's initial value, rather than assigning to it inside { }. The body then records the account's opening balance as the first entry in its transaction history.

Account::Account(int accNum, const std::string &name, double startingBalance)
    : accountNumber(accNum), holderName(name), balance(startingBalance) {   // Member initializer list, runs before the body
    history.push_back("Opened with balance " + formatMoney(startingBalance));   // First entry in this account's history
}

The Account:: prefix is the scope resolution syntax that tells the compiler "this is the definition of the constructor I declared inside class Account," rather than a brand-new, unrelated function that happens to share a name.

Step 3: Deposit, Withdraw, and Transaction History

Both deposit and withdraw validate their input before ever touching balance, which is exactly the protection encapsulation is meant to provide — no code outside this class can create an invalid balance, because no code outside this class can touch balance at all. Every successful operation appends a human-readable line to history, which printHistory can replay later.

void Account::deposit(double amount) {
    if (amount <= 0) {                                    // Reject zero or negative deposits up front
        std::cout << "Deposit amount must be positive.\n";
        return;
    }
    balance += amount;                                    // Encapsulation: only this method may change balance
    history.push_back("Deposited " + formatMoney(amount) + ", new balance " + formatMoney(balance));
    std::cout << "Deposited " << formatMoney(amount) << ". New balance: " << formatMoney(balance) << "\n";
}

void Account::withdraw(double amount) {
    if (amount <= 0) {                                    // Reject zero or negative withdrawal amounts
        std::cout << "Withdrawal amount must be positive.\n";
        return;
    }
    if (amount > balance) {                               // Reject overdrafts before balance is ever touched
        std::cout << "Insufficient funds. Current balance: " << formatMoney(balance) << "\n";
        return;
    }
    balance -= amount;                                    // Both checks passed, safe to subtract
    history.push_back("Withdrew " + formatMoney(amount) + ", new balance " + formatMoney(balance));
    std::cout << "Withdrew " << formatMoney(amount) << ". New balance: " << formatMoney(balance) << "\n";
}

void Account::printHistory() const {
    std::cout << "Transaction history for account #" << accountNumber << ":\n";
    for (const std::string &entry : history) {   // Range-based for loop over every recorded entry, in order
        std::cout << "  - " << entry << "\n";
    }
}

Example Usage

Click Run to see what this code prints.

Step 4: Manage Multiple Accounts With a Bank Class

A single Account is not a banking system — the Bank class is what turns it into one, by owning a std::vector<Account> and a counter that hands out the next unused account number. findAccount returns an Account* pointing directly into the vector, so the caller can deposit or withdraw on it without searching a second time. One caveat worth knowing up front: because std::vector can reallocate its internal storage when it grows, a pointer returned by findAccount should be used immediately and not kept around across a later call to createAccount — the "Extend This Project" section below suggests a fix using std::map if that limitation ever matters for a larger version of this project.

class Bank {
private:
    std::vector<Account> accounts;    // Every account currently loaded into memory
    int nextAccountNumber;            // Auto-incrementing counter used to assign new account numbers

public:
    Bank() : nextAccountNumber(1001) {}   // First account created this run will be numbered 1001

    Account* findAccount(int accNum);      // Defined in this step
    void createAccount(const std::string &name, double startingBalance);   // Defined in this step
    void listAccounts() const;              // Defined in this step

    void saveToFile(const std::string &filename) const;   // Defined in Step 5
    void loadFromFile(const std::string &filename);          // Defined in Step 5
};

Account* Bank::findAccount(int accNum) {   // Returns a pointer into the vector so callers can modify the account directly
    for (Account &acc : accounts) {         // Non-const reference so we can hand back a non-const pointer
        if (acc.getAccountNumber() == accNum) {
            return &acc;                    // Found it: hand back its address, not a copy
        }
    }
    return nullptr;                         // No match; callers must check for this before dereferencing
}

void Bank::createAccount(const std::string &name, double startingBalance) {
    accounts.push_back(Account(nextAccountNumber, name, startingBalance));   // Copy-construct a new Account into the vector
    std::cout << "Account created! Your account number is " << nextAccountNumber << ".\n";
    nextAccountNumber++;   // Guarantees every future account gets a unique number
}

void Bank::listAccounts() const {
    std::cout << "\nAccount#\tHolder\t\tBalance\n";
    for (const Account &acc : accounts) {
        std::cout << acc.getAccountNumber() << "\t\t" << acc.getHolderName()
                  << "\t\t" << formatMoney(acc.getBalance()) << "\n";
    }
}

Step 5: Persist Accounts to a File

saveToFile writes one comma-separated line per account, and loadFromFile reads those lines back with std::getline and std::stringstream, splitting each line on commas to recover the account number, name, and balance as their original types with std::stoi and std::stod. Loading also tracks the highest account number seen, so nextAccountNumber resumes correctly instead of restarting at 1001 and risking a collision with an account already on disk.

void Bank::saveToFile(const std::string &filename) const {
    std::ofstream out(filename);   // ofstream creates the file if missing, truncates it if it already exists
    for (const Account &acc : accounts) {
        // Comma-separated line: account number, holder name, balance
        out << acc.getAccountNumber() << "," << acc.getHolderName() << "," << acc.getBalance() << "\n";
    }
    out.close();   // Flush and release the file handle
}

void Bank::loadFromFile(const std::string &filename) {
    std::ifstream in(filename);   // Attempt to open the saved accounts file
    if (!in.is_open()) {          // No file yet means this is the first run; nothing to load
        return;
    }

    std::string line;
    int highestSeen = 1000;       // Tracks the largest account number found, so numbering resumes correctly
    while (std::getline(in, line)) {   // Read one comma-separated record per line
        std::stringstream ss(line);
        std::string numStr, name, balStr;
        std::getline(ss, numStr, ',');   // First field: account number
        std::getline(ss, name, ',');     // Second field: holder name
        std::getline(ss, balStr, ',');   // Third field: balance

        int num = std::stoi(numStr);     // Convert the text fields back into their real types
        double bal = std::stod(balStr);
        accounts.push_back(Account(num, name, bal));
        if (num > highestSeen) {
            highestSeen = num;
        }
    }
    nextAccountNumber = highestSeen + 1;   // Resume numbering after the highest account loaded from disk
    in.close();
}

Step 6: Build the Menu Loop

main loads any existing accounts, then loops over a numbered menu until the user exits, saving to disk immediately after every change so no transaction is lost even if the program closes unexpectedly.

int main() {
    Bank bank;                              // One Bank object owns every account for this run
    const std::string filename = "accounts.txt";
    bank.loadFromFile(filename);            // Restore whatever accounts were saved from a previous run

    int choice;
    do {
        std::cout << "\n===== BANK MANAGEMENT SYSTEM =====\n";
        std::cout << "1. Create Account\n";
        std::cout << "2. Deposit\n";
        std::cout << "3. Withdraw\n";
        std::cout << "4. Check Balance\n";
        std::cout << "5. View Transaction History\n";
        std::cout << "6. List All Accounts\n";
        std::cout << "7. Exit\n";
        std::cout << "Enter your choice: ";
        std::cin >> choice;

        if (choice == 1) {
            std::string name;
            double startingBalance;
            std::cout << "Enter account holder name: ";
            std::cin.ignore();                        // Discard the leftover newline left behind by "std::cin >> choice"
            std::getline(std::cin, name);              // getline captures names containing spaces
            std::cout << "Enter starting balance: ";
            std::cin >> startingBalance;
            if (startingBalance < 0) {                  // Defend against a negative opening balance
                std::cout << "Starting balance cannot be negative. Setting balance to 0.\n";
                startingBalance = 0;
            }
            bank.createAccount(name, startingBalance);
            bank.saveToFile(filename);                  // Persist immediately so a new account survives an unexpected exit
        } else if (choice == 2) {
            int accNum;
            double amount;
            std::cout << "Enter account number: ";
            std::cin >> accNum;
            Account *acc = bank.findAccount(accNum);
            if (acc == nullptr) {
                std::cout << "Account not found.\n";
            } else {
                std::cout << "Enter deposit amount: ";
                std::cin >> amount;
                acc->deposit(amount);
                bank.saveToFile(filename);
            }
        } else if (choice == 3) {
            int accNum;
            double amount;
            std::cout << "Enter account number: ";
            std::cin >> accNum;
            Account *acc = bank.findAccount(accNum);
            if (acc == nullptr) {
                std::cout << "Account not found.\n";
            } else {
                std::cout << "Enter withdrawal amount: ";
                std::cin >> amount;
                acc->withdraw(amount);
                bank.saveToFile(filename);
            }
        } else if (choice == 4) {
            int accNum;
            std::cout << "Enter account number: ";
            std::cin >> accNum;
            Account *acc = bank.findAccount(accNum);
            if (acc == nullptr) {
                std::cout << "Account not found.\n";
            } else {
                std::cout << "Account #" << acc->getAccountNumber() << " (" << acc->getHolderName()
                          << ") - Balance: " << formatMoney(acc->getBalance()) << "\n";
            }
        } else if (choice == 5) {
            int accNum;
            std::cout << "Enter account number: ";
            std::cin >> accNum;
            Account *acc = bank.findAccount(accNum);
            if (acc == nullptr) {
                std::cout << "Account not found.\n";
            } else {
                acc->printHistory();
            }
        } else if (choice == 6) {
            bank.listAccounts();
        } else if (choice == 7) {
            std::cout << "Goodbye!\n";
        } else {
            std::cout << "Invalid choice, try again.\n";   // Catches anything outside 1-7
        }
    } while (choice != 7);   // Keep looping until the user explicitly picks Exit

    return 0;
}

Complete Code

Here is the full program with every declaration and definition assembled in the correct order, ready to compile with g++ bank.cpp -o bank.

#include <iostream>   // std::cin/std::cout for all console interaction
#include <fstream>    // std::ifstream/std::ofstream for reading and writing account data to disk
#include <sstream>    // std::stringstream/std::ostringstream for parsing and formatting text
#include <iomanip>    // std::fixed/std::setprecision for two-decimal money formatting
#include <string>     // std::string and std::to_string/std::stoi/std::stod
#include <vector>     // std::vector to hold each account's transaction history and the bank's accounts

// Formats a monetary amount as a fixed two-decimal string, e.g. 1500 -> "1500.00"
std::string formatMoney(double amount) {
    std::ostringstream oss;
    oss << std::fixed << std::setprecision(2) << amount;
    return oss.str();
}

class Account {
private:
    int accountNumber;                  // Unique ID assigned by the Bank when the account is created
    std::string holderName;             // Account holder's name
    double balance;                     // Current balance; private so it can only change via deposit()/withdraw()
    std::vector<std::string> history;   // Log of every transaction made on this account

public:
    Account(int accNum, const std::string &name, double startingBalance);

    int getAccountNumber() const { return accountNumber; }
    std::string getHolderName() const { return holderName; }
    double getBalance() const { return balance; }

    void deposit(double amount);
    void withdraw(double amount);
    void printHistory() const;
};

Account::Account(int accNum, const std::string &name, double startingBalance)
    : accountNumber(accNum), holderName(name), balance(startingBalance) {
    history.push_back("Opened with balance " + formatMoney(startingBalance));
}

void Account::deposit(double amount) {
    if (amount <= 0) {
        std::cout << "Deposit amount must be positive.\n";
        return;
    }
    balance += amount;
    history.push_back("Deposited " + formatMoney(amount) + ", new balance " + formatMoney(balance));
    std::cout << "Deposited " << formatMoney(amount) << ". New balance: " << formatMoney(balance) << "\n";
}

void Account::withdraw(double amount) {
    if (amount <= 0) {
        std::cout << "Withdrawal amount must be positive.\n";
        return;
    }
    if (amount > balance) {
        std::cout << "Insufficient funds. Current balance: " << formatMoney(balance) << "\n";
        return;
    }
    balance -= amount;
    history.push_back("Withdrew " + formatMoney(amount) + ", new balance " + formatMoney(balance));
    std::cout << "Withdrew " << formatMoney(amount) << ". New balance: " << formatMoney(balance) << "\n";
}

void Account::printHistory() const {
    std::cout << "Transaction history for account #" << accountNumber << ":\n";
    for (const std::string &entry : history) {
        std::cout << "  - " << entry << "\n";
    }
}

class Bank {
private:
    std::vector<Account> accounts;
    int nextAccountNumber;

public:
    Bank() : nextAccountNumber(1001) {}

    Account* findAccount(int accNum);
    void createAccount(const std::string &name, double startingBalance);
    void listAccounts() const;

    void saveToFile(const std::string &filename) const;
    void loadFromFile(const std::string &filename);
};

Account* Bank::findAccount(int accNum) {
    for (Account &acc : accounts) {
        if (acc.getAccountNumber() == accNum) {
            return &acc;
        }
    }
    return nullptr;
}

void Bank::createAccount(const std::string &name, double startingBalance) {
    accounts.push_back(Account(nextAccountNumber, name, startingBalance));
    std::cout << "Account created! Your account number is " << nextAccountNumber << ".\n";
    nextAccountNumber++;
}

void Bank::listAccounts() const {
    std::cout << "\nAccount#\tHolder\t\tBalance\n";
    for (const Account &acc : accounts) {
        std::cout << acc.getAccountNumber() << "\t\t" << acc.getHolderName()
                  << "\t\t" << formatMoney(acc.getBalance()) << "\n";
    }
}

void Bank::saveToFile(const std::string &filename) const {
    std::ofstream out(filename);
    for (const Account &acc : accounts) {
        out << acc.getAccountNumber() << "," << acc.getHolderName() << "," << acc.getBalance() << "\n";
    }
    out.close();
}

void Bank::loadFromFile(const std::string &filename) {
    std::ifstream in(filename);
    if (!in.is_open()) {
        return;
    }

    std::string line;
    int highestSeen = 1000;
    while (std::getline(in, line)) {
        std::stringstream ss(line);
        std::string numStr, name, balStr;
        std::getline(ss, numStr, ',');
        std::getline(ss, name, ',');
        std::getline(ss, balStr, ',');

        int num = std::stoi(numStr);
        double bal = std::stod(balStr);
        accounts.push_back(Account(num, name, bal));
        if (num > highestSeen) {
            highestSeen = num;
        }
    }
    nextAccountNumber = highestSeen + 1;
    in.close();
}

int main() {
    Bank bank;
    const std::string filename = "accounts.txt";
    bank.loadFromFile(filename);

    int choice;
    do {
        std::cout << "\n===== BANK MANAGEMENT SYSTEM =====\n";
        std::cout << "1. Create Account\n";
        std::cout << "2. Deposit\n";
        std::cout << "3. Withdraw\n";
        std::cout << "4. Check Balance\n";
        std::cout << "5. View Transaction History\n";
        std::cout << "6. List All Accounts\n";
        std::cout << "7. Exit\n";
        std::cout << "Enter your choice: ";
        std::cin >> choice;

        if (choice == 1) {
            std::string name;
            double startingBalance;
            std::cout << "Enter account holder name: ";
            std::cin.ignore();
            std::getline(std::cin, name);
            std::cout << "Enter starting balance: ";
            std::cin >> startingBalance;
            if (startingBalance < 0) {
                std::cout << "Starting balance cannot be negative. Setting balance to 0.\n";
                startingBalance = 0;
            }
            bank.createAccount(name, startingBalance);
            bank.saveToFile(filename);
        } else if (choice == 2) {
            int accNum;
            double amount;
            std::cout << "Enter account number: ";
            std::cin >> accNum;
            Account *acc = bank.findAccount(accNum);
            if (acc == nullptr) {
                std::cout << "Account not found.\n";
            } else {
                std::cout << "Enter deposit amount: ";
                std::cin >> amount;
                acc->deposit(amount);
                bank.saveToFile(filename);
            }
        } else if (choice == 3) {
            int accNum;
            double amount;
            std::cout << "Enter account number: ";
            std::cin >> accNum;
            Account *acc = bank.findAccount(accNum);
            if (acc == nullptr) {
                std::cout << "Account not found.\n";
            } else {
                std::cout << "Enter withdrawal amount: ";
                std::cin >> amount;
                acc->withdraw(amount);
                bank.saveToFile(filename);
            }
        } else if (choice == 4) {
            int accNum;
            std::cout << "Enter account number: ";
            std::cin >> accNum;
            Account *acc = bank.findAccount(accNum);
            if (acc == nullptr) {
                std::cout << "Account not found.\n";
            } else {
                std::cout << "Account #" << acc->getAccountNumber() << " (" << acc->getHolderName()
                          << ") - Balance: " << formatMoney(acc->getBalance()) << "\n";
            }
        } else if (choice == 5) {
            int accNum;
            std::cout << "Enter account number: ";
            std::cin >> accNum;
            Account *acc = bank.findAccount(accNum);
            if (acc == nullptr) {
                std::cout << "Account not found.\n";
            } else {
                acc->printHistory();
            }
        } else if (choice == 6) {
            bank.listAccounts();
        } else if (choice == 7) {
            std::cout << "Goodbye!\n";
        } else {
            std::cout << "Invalid choice, try again.\n";
        }
    } while (choice != 7);

    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 history lookup succeeds.
Write a transferFunds(Account &from, Account &to, double amount) function that withdraws from one account and deposits into another as one operation.
Switch Bank's storage from std::vector<Account> to std::map<int, Account> keyed by account number, which avoids the pointer-invalidation caveat from Step 4 and makes lookups faster for a large bank.
Persist the full transaction history to its own file instead of only in memory, so printHistory() still works after the program restarts.
Add an interest calculation feature that applies a fixed annual rate to every account's balance when the user selects a "Run Interest Cycle" menu option.

Summary

You built a working bank management system that uses classes the way real C++ programs do: Account protects its own balance behind private fields and validated public methods, and Bank composes many accounts into one manageable collection. The declare-in-the-class, define-with-ClassName::-outside pattern you used throughout is the same one you will see in virtually every non-trivial C++ codebase, and the text-based file persistence you wrote will work correctly no matter what data types your classes end up containing.