Inventory Management System

Manage stock and orders efficiently using STL containers like vectors and maps.

STLTemplatesFile Handling

Overview

An inventory system spends most of its time doing one thing: looking up a product by ID and changing its quantity, whether that is restocking shelves or shipping out an order. That access pattern — look up by a unique key, then read or update — is exactly what `std::map` is built for, and it is a natural upgrade from the array-based lookups you may have used in earlier projects, since `std::map` keeps every product sorted by ID automatically and finds any entry in logarithmic time no matter how large the catalog grows.

By the end of this tutorial you will have a console inventory application built around an `Item` class, a `std::map<int, Item>` keyed by product ID, and a small but genuinely reusable template function that validates numeric input — the same validation loop working for both integer quantities and floating-point prices without being written twice. Inventory data is also persisted to disk with `<fstream>`, so stock levels survive between runs.

What You'll Build

An `Item` class representing one product: ID, name, quantity, and price.
A `template <typename T> T getValidatedInput(...)` function reused for both quantities and prices.
An `Inventory` class managing a `std::map<int, Item>` keyed by product ID.
Restock and "place order" operations that add or safely subtract stock.
A low-stock report that scans the map for items below a chosen threshold.
File persistence with `std::ofstream`/`std::ifstream` so inventory survives between runs.

Prerequisites

Classes — `private` fields, constructors, and member functions.
STL containers — `std::map<Key, Value>`, its `find()`/`begin()`/`end()` interface, and iterating with a range-based `for` loop.
Templates — the basic shape of `template <typename T> ReturnType functionName(...)`.
File handling in C++ — `std::ofstream`/`std::ifstream` and parsing text with `std::stringstream`.
Basic validation logic — checking `std::cin.fail()` after a read and clearing the stream to recover.

Project Structure

The program lives in a single file, `inventory.cpp`. `Item` is a small value class holding one product's data; it never talks to the console or the file system itself, keeping it easy to reuse or test in isolation. `Inventory` owns a `std::map<int, Item>`, where the key is the product ID and the value is the `Item` itself — choosing a map over a `std::vector<Item>` here has a real, practical benefit: because `std::map` is node-based internally, adding a brand-new item never invalidates a pointer you already obtained from `find()` on a different item, unlike a `std::vector`, which can reallocate its entire buffer and invalidate every pointer into it when it grows.

The one genuinely generic piece of this project is `getValidatedInput<T>`, a function template that reads a value of type `T` and keeps re-prompting until it is both numeric and at least a caller-supplied minimum. It is instantiated twice in this project — once as `getValidatedInput<int>` for quantities, once as `getValidatedInput<double>` for prices — and the compiler generates a separate, type-specific version of the function for each, without you writing either loop by hand twice.

Step 1: Define the Item Class

Every field an item needs — ID, name, quantity, price — lives behind `private` access, with `addStock`/`removeStock` as the only ways quantity ever changes. `removeStock` returns `bool` rather than blindly subtracting, so callers can reject an order that would take stock negative.

#include <iostream>   // std::cin/std::cout for all console interaction
#include <fstream>    // std::ifstream/std::ofstream for reading and writing inventory data to disk
#include <sstream>    // std::stringstream for splitting a saved comma-separated line back into fields
#include <iomanip>    // std::fixed/std::setprecision for two-decimal price formatting
#include <string>     // std::string for item names and std::stoi/std::stod for parsing
#include <map>        // std::map<int, Item> keyed by product ID

class Item {
private:
    int id;             // Unique product ID, also the key used to store this item in the Inventory's map
    std::string name;   // Product name
    int quantity;         // Units currently in stock
    double price;          // Price per unit

public:
    Item() : id(0), quantity(0), price(0.0) {}   // Default constructor: std::map needs this to create empty slots internally
    Item(int id, const std::string &name, int quantity, double price)
        : id(id), name(name), quantity(quantity), price(price) {}

    int getId() const { return id; }
    std::string getName() const { return name; }
    int getQuantity() const { return quantity; }
    double getPrice() const { return price; }

    void addStock(int amount) { quantity += amount; }   // Restocking always increases quantity
    bool removeStock(int amount) {                        // Returns false instead of ever allowing negative stock
        if (amount > quantity) {
            return false;
        }
        quantity -= amount;
        return true;
    }

    double totalValue() const { return quantity * price; }   // Convenience calculation used in reports

    void display() const {
        std::cout << id << "\t" << name << "\t" << quantity << "\t"
                  << price << "\t" << totalValue() << "\n";
    }
};

Step 2: Write a Generic Input-Validation Template

Without a template, validating a quantity (`int`) and validating a price (`double`) would mean writing the exact same "read, check for failure, check the minimum, retry" loop twice with only the type changed. `template <typename T>` lets the compiler generate both versions from one function body, so the logic is written, tested, and fixed in exactly one place.

// Generic input-validation helper: reads a value of type T and keeps re-prompting
// until it is numeric and at least minValue. One template serves both int quantities
// and double prices, instead of duplicating this loop for each type.
template <typename T>
T getValidatedInput(const std::string &prompt, T minValue) {
    T value;
    while (true) {
        std::cout << prompt;
        std::cin >> value;
        if (std::cin.fail()) {                   // Non-numeric input, e.g. the user typed letters
            std::cin.clear();                     // Clear the stream's fail flag so later reads still work
            std::cin.ignore(10000, '\n');          // Discard the bad input still sitting in the buffer
            std::cout << "Invalid input, please enter a number.\n";
            continue;
        }
        if (value < minValue) {                    // Enforce the caller's minimum (e.g. quantity >= 0)
            std::cout << "Value must be at least " << minValue << ".\n";
            continue;
        }
        return value;                               // Only reached once a valid, in-range value was read
    }
}

Two Instantiations of the Same Template

Click Run to see what this code prints.

Step 3: Build the Inventory Class Around a Map

`addItem` uses `items[nextId] = ...`, which inserts a brand-new entry because `nextId` has never been used as a key before. `findItem` deliberately uses `items.find(id)` rather than `items[id]` — `operator[]` would silently insert a default-constructed `Item` for a missing ID, which is exactly the bug `find()` avoids, since `find()` only ever looks, never inserts.

class Inventory {
private:
    std::map<int, Item> items;   // Keyed by product ID; std::map keeps entries sorted by key automatically
    int nextId;                   // Auto-incrementing counter used to assign new product IDs

public:
    Inventory() : nextId(1) {}   // First item added this run will be product ID 1

    void addItem(const std::string &name, int quantity, double price);   // Defined in this step
    Item* findItem(int id);                                                // Defined in this step
    void listItems() const;                                                 // Defined in this step

    void restock(int id, int amount);           // Defined in Step 4
    void placeOrder(int id, int amount);          // Defined in Step 4
    void lowStockReport(int threshold) const;      // Defined in Step 4

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

void Inventory::addItem(const std::string &name, int quantity, double price) {
    items[nextId] = Item(nextId, name, quantity, price);   // operator[] inserts a new entry at key nextId
    std::cout << "Added \"" << name << "\" with product ID " << nextId << ".\n";
    nextId++;   // Guarantees the next item gets a fresh, unused ID
}

Item* Inventory::findItem(int id) {
    std::map<int, Item>::iterator it = items.find(id);   // find() looks up without inserting a default entry
    if (it == items.end()) {                               // end() means no entry with that key exists
        return nullptr;
    }
    return &it->second;   // ->second is the Item stored at this key; ->first would be the key itself
}

void Inventory::listItems() const {
    std::cout << "\nID\tName\tQty\tPrice\tTotal Value\n";
    for (std::map<int, Item>::const_iterator it = items.begin(); it != items.end(); ++it) {   // Ascending key order, guaranteed by std::map
        it->second.display();
    }
}

Step 4: Restock, Place Orders, and Report Low Stock

`restock` and `placeOrder` both start by finding the item and bailing out if it does not exist, then delegate the actual quantity change to `Item::addStock`/`Item::removeStock` — `Inventory` never touches `quantity` directly, it just orchestrates the lookup and reports the result. `lowStockReport` reuses the same map-iteration pattern from `listItems`, adding one condition to filter which items get printed.

void Inventory::restock(int id, int amount) {
    Item *item = findItem(id);
    if (item == nullptr) {
        std::cout << "Item not found.\n";
        return;
    }
    item->addStock(amount);
    std::cout << "Restocked " << amount << " units of \"" << item->getName() << "\".\n";
}

void Inventory::placeOrder(int id, int amount) {   // "Placing an order" removes stock as it ships out
    Item *item = findItem(id);
    if (item == nullptr) {
        std::cout << "Item not found.\n";
        return;
    }
    if (!item->removeStock(amount)) {
        std::cout << "Not enough stock. Available: " << item->getQuantity() << "\n";
        return;
    }
    std::cout << "Order placed: " << amount << " units of \"" << item->getName() << "\".\n";
}

void Inventory::lowStockReport(int threshold) const {
    std::cout << "\n--- Low Stock Items (below " << threshold << ") ---\n";
    for (std::map<int, Item>::const_iterator it = items.begin(); it != items.end(); ++it) {
        if (it->second.getQuantity() < threshold) {   // Only print items under the threshold
            it->second.display();
        }
    }
}

Step 5: Persist the Inventory to a File

Saving and loading follow the same comma-separated text pattern used elsewhere in this course: one line per item, split back into fields with `std::stringstream` on load. As with the Bank Management System project, loading also tracks the highest ID seen so `nextId` resumes correctly instead of colliding with an item already on disk.

void Inventory::saveToFile(const std::string &filename) const {
    std::ofstream out(filename);   // ofstream creates the file if missing, truncates it if it already exists
    for (std::map<int, Item>::const_iterator it = items.begin(); it != items.end(); ++it) {
        const Item &item = it->second;
        out << item.getId() << "," << item.getName() << "," << item.getQuantity() << "," << item.getPrice() << "\n";
    }
    out.close();
}

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

    std::string line;
    int highestSeen = 0;
    while (std::getline(in, line)) {   // Read one comma-separated record per line
        std::stringstream ss(line);
        std::string idStr, name, qtyStr, priceStr;
        std::getline(ss, idStr, ',');
        std::getline(ss, name, ',');
        std::getline(ss, qtyStr, ',');
        std::getline(ss, priceStr, ',');

        int id = std::stoi(idStr);       // Convert the text fields back into their real types
        int qty = std::stoi(qtyStr);
        double price = std::stod(priceStr);
        items[id] = Item(id, name, qty, price);
        if (id > highestSeen) {
            highestSeen = id;
        }
    }
    nextId = highestSeen + 1;   // Resume numbering after the highest ID loaded from disk
    in.close();
}

Step 6: Build the Menu Loop

`main` loads any existing inventory, then loops over a numbered menu, using `getValidatedInput<int>`/`getValidatedInput<double>` everywhere a quantity or price needs to be read so bad input never crashes the program or corrupts the map.

int main() {
    Inventory inventory;
    const std::string filename = "inventory.txt";
    inventory.loadFromFile(filename);   // Restore whatever stock levels were saved from a previous run

    std::cout << std::fixed << std::setprecision(2);   // All prices/values print with exactly two decimals from here on

    int choice;
    do {
        std::cout << "\n===== INVENTORY MANAGEMENT SYSTEM =====\n";
        std::cout << "1. Add Item\n";
        std::cout << "2. Restock Item\n";
        std::cout << "3. Place Order (Remove Stock)\n";
        std::cout << "4. List Items\n";
        std::cout << "5. Low Stock Report\n";
        std::cout << "6. Exit\n";
        std::cout << "Enter your choice: ";
        std::cin >> choice;

        if (choice == 1) {
            std::string name;
            std::cout << "Enter item name: ";
            std::cin.ignore();                   // Discard the leftover newline left behind by "std::cin >> choice"
            std::getline(std::cin, name);
            int quantity = getValidatedInput<int>("Enter starting quantity: ", 0);      // Template instantiated for int
            double price = getValidatedInput<double>("Enter price per unit: ", 0.0);    // Same template, instantiated for double
            inventory.addItem(name, quantity, price);
            inventory.saveToFile(filename);
        } else if (choice == 2) {
            int id = getValidatedInput<int>("Enter item ID to restock: ", 1);
            int amount = getValidatedInput<int>("Enter quantity to add: ", 1);
            inventory.restock(id, amount);
            inventory.saveToFile(filename);
        } else if (choice == 3) {
            int id = getValidatedInput<int>("Enter item ID to order: ", 1);
            int amount = getValidatedInput<int>("Enter quantity to remove: ", 1);
            inventory.placeOrder(id, amount);
            inventory.saveToFile(filename);
        } else if (choice == 4) {
            inventory.listItems();
        } else if (choice == 5) {
            int threshold = getValidatedInput<int>("Enter low-stock threshold: ", 1);
            inventory.lowStockReport(threshold);
        } else if (choice == 6) {
            std::cout << "Goodbye!\n";
        } else {
            std::cout << "Invalid choice, try again.\n";
        }
    } while (choice != 6);   // Keep looping until the user explicitly picks Exit

    return 0;
}

Complete Code

Here is the full program, ready to compile with `g++ inventory.cpp -o inventory`.

#include <iostream>   // std::cin/std::cout for all console interaction
#include <fstream>    // std::ifstream/std::ofstream for reading and writing inventory data to disk
#include <sstream>    // std::stringstream for splitting a saved comma-separated line back into fields
#include <iomanip>    // std::fixed/std::setprecision for two-decimal price formatting
#include <string>     // std::string for item names and std::stoi/std::stod for parsing
#include <map>        // std::map<int, Item> keyed by product ID

class Item {
private:
    int id;
    std::string name;
    int quantity;
    double price;

public:
    Item() : id(0), quantity(0), price(0.0) {}
    Item(int id, const std::string &name, int quantity, double price)
        : id(id), name(name), quantity(quantity), price(price) {}

    int getId() const { return id; }
    std::string getName() const { return name; }
    int getQuantity() const { return quantity; }
    double getPrice() const { return price; }

    void addStock(int amount) { quantity += amount; }
    bool removeStock(int amount) {
        if (amount > quantity) {
            return false;
        }
        quantity -= amount;
        return true;
    }

    double totalValue() const { return quantity * price; }

    void display() const {
        std::cout << id << "\t" << name << "\t" << quantity << "\t"
                  << price << "\t" << totalValue() << "\n";
    }
};

template <typename T>
T getValidatedInput(const std::string &prompt, T minValue) {
    T value;
    while (true) {
        std::cout << prompt;
        std::cin >> value;
        if (std::cin.fail()) {
            std::cin.clear();
            std::cin.ignore(10000, '\n');
            std::cout << "Invalid input, please enter a number.\n";
            continue;
        }
        if (value < minValue) {
            std::cout << "Value must be at least " << minValue << ".\n";
            continue;
        }
        return value;
    }
}

class Inventory {
private:
    std::map<int, Item> items;
    int nextId;

public:
    Inventory() : nextId(1) {}

    void addItem(const std::string &name, int quantity, double price);
    Item* findItem(int id);
    void listItems() const;

    void restock(int id, int amount);
    void placeOrder(int id, int amount);
    void lowStockReport(int threshold) const;

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

void Inventory::addItem(const std::string &name, int quantity, double price) {
    items[nextId] = Item(nextId, name, quantity, price);
    std::cout << "Added \"" << name << "\" with product ID " << nextId << ".\n";
    nextId++;
}

Item* Inventory::findItem(int id) {
    std::map<int, Item>::iterator it = items.find(id);
    if (it == items.end()) {
        return nullptr;
    }
    return &it->second;
}

void Inventory::listItems() const {
    std::cout << "\nID\tName\tQty\tPrice\tTotal Value\n";
    for (std::map<int, Item>::const_iterator it = items.begin(); it != items.end(); ++it) {
        it->second.display();
    }
}

void Inventory::restock(int id, int amount) {
    Item *item = findItem(id);
    if (item == nullptr) {
        std::cout << "Item not found.\n";
        return;
    }
    item->addStock(amount);
    std::cout << "Restocked " << amount << " units of \"" << item->getName() << "\".\n";
}

void Inventory::placeOrder(int id, int amount) {
    Item *item = findItem(id);
    if (item == nullptr) {
        std::cout << "Item not found.\n";
        return;
    }
    if (!item->removeStock(amount)) {
        std::cout << "Not enough stock. Available: " << item->getQuantity() << "\n";
        return;
    }
    std::cout << "Order placed: " << amount << " units of \"" << item->getName() << "\".\n";
}

void Inventory::lowStockReport(int threshold) const {
    std::cout << "\n--- Low Stock Items (below " << threshold << ") ---\n";
    for (std::map<int, Item>::const_iterator it = items.begin(); it != items.end(); ++it) {
        if (it->second.getQuantity() < threshold) {
            it->second.display();
        }
    }
}

void Inventory::saveToFile(const std::string &filename) const {
    std::ofstream out(filename);
    for (std::map<int, Item>::const_iterator it = items.begin(); it != items.end(); ++it) {
        const Item &item = it->second;
        out << item.getId() << "," << item.getName() << "," << item.getQuantity() << "," << item.getPrice() << "\n";
    }
    out.close();
}

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

    std::string line;
    int highestSeen = 0;
    while (std::getline(in, line)) {
        std::stringstream ss(line);
        std::string idStr, name, qtyStr, priceStr;
        std::getline(ss, idStr, ',');
        std::getline(ss, name, ',');
        std::getline(ss, qtyStr, ',');
        std::getline(ss, priceStr, ',');

        int id = std::stoi(idStr);
        int qty = std::stoi(qtyStr);
        double price = std::stod(priceStr);
        items[id] = Item(id, name, qty, price);
        if (id > highestSeen) {
            highestSeen = id;
        }
    }
    nextId = highestSeen + 1;
    in.close();
}

int main() {
    Inventory inventory;
    const std::string filename = "inventory.txt";
    inventory.loadFromFile(filename);

    std::cout << std::fixed << std::setprecision(2);

    int choice;
    do {
        std::cout << "\n===== INVENTORY MANAGEMENT SYSTEM =====\n";
        std::cout << "1. Add Item\n";
        std::cout << "2. Restock Item\n";
        std::cout << "3. Place Order (Remove Stock)\n";
        std::cout << "4. List Items\n";
        std::cout << "5. Low Stock Report\n";
        std::cout << "6. Exit\n";
        std::cout << "Enter your choice: ";
        std::cin >> choice;

        if (choice == 1) {
            std::string name;
            std::cout << "Enter item name: ";
            std::cin.ignore();
            std::getline(std::cin, name);
            int quantity = getValidatedInput<int>("Enter starting quantity: ", 0);
            double price = getValidatedInput<double>("Enter price per unit: ", 0.0);
            inventory.addItem(name, quantity, price);
            inventory.saveToFile(filename);
        } else if (choice == 2) {
            int id = getValidatedInput<int>("Enter item ID to restock: ", 1);
            int amount = getValidatedInput<int>("Enter quantity to add: ", 1);
            inventory.restock(id, amount);
            inventory.saveToFile(filename);
        } else if (choice == 3) {
            int id = getValidatedInput<int>("Enter item ID to order: ", 1);
            int amount = getValidatedInput<int>("Enter quantity to remove: ", 1);
            inventory.placeOrder(id, amount);
            inventory.saveToFile(filename);
        } else if (choice == 4) {
            inventory.listItems();
        } else if (choice == 5) {
            int threshold = getValidatedInput<int>("Enter low-stock threshold: ", 1);
            inventory.lowStockReport(threshold);
        } else if (choice == 6) {
            std::cout << "Goodbye!\n";
        } else {
            std::cout << "Invalid choice, try again.\n";
        }
    } while (choice != 6);

    return 0;
}

Sample Run

Click Run to see what this code prints.

Extend This Project

Add a `Supplier` field to `Item` and a report grouping total inventory value by supplier using a `std::map<std::string, double>`.
Log every restock and order to a separate `transactions.txt` file, similar to the transaction history in the Bank Management System project.
Add a second template function, `template <typename T> T findMax(const std::vector<T> &values)`, and use it to report the single most valuable item in stock.
Support categories (e.g. "Electronics", "Stationery") using `std::map<std::string, std::vector<int>>` mapping each category to the product IDs in it.
Add an "Order History" report that keeps a running total of units sold per item, separate from current stock on hand.

Summary

You built an inventory system where `std::map` does the lookup work an array-and-loop approach would otherwise require by hand, and where one small template function replaced two nearly-identical validation loops. Reaching for the STL container that matches your actual access pattern — keyed lookup here, sequence elsewhere — and reaching for a template when the same logic needs to work across more than one type, are two habits that will make every C++ project after this one noticeably shorter and more reliable.