C++ Program To Print The Bill

In this article, you will learn how to create C++ programs to generate and print a basic bill, covering different approaches from simple hardcoded examples to more interactive and structured solutions. We will explore how to manage item details, calculate totals, and present the information clearly.

Problem Statement

Generating a bill or invoice is a fundamental requirement for many businesses and applications, from small retail shops to online e-commerce platforms. The core problem involves taking a list of items, their quantities, and prices, then calculating the subtotal, taxes (if any), and the final total amount payable. Presenting this information in a clear, formatted manner is crucial for both the vendor and the customer.

Example

Imagine a simple scenario where a customer buys a few items. A basic bill might look something like this:

----------------------------------------
              YOUR RECEIPT
----------------------------------------
Item              Qty   Price    Total
----------------------------------------
Laptop             1    $1200.00 $1200.00
Mouse              2    $25.00   $50.00
Keyboard           1    $75.00   $75.00
----------------------------------------
Subtotal:                  $1325.00
Tax (8%):                  $106.00
----------------------------------------
Grand Total:               $1431.00
----------------------------------------
Thank You!

Background & Knowledge Prerequisites

To follow this article effectively, you should have a basic understanding of:

• C++ Syntax: How to write simple C++ programs.
• Variables and Data Types: int, double, string.
• Input/Output Operations: Using cout for printing and cin for input.
• Conditional Statements: if, else if, else.
• Loops: for and while loops for iteration.
• Functions: Basic function definition and calls.

Relevant imports needed will typically include for input/output and potentially for formatting.

Use Cases or Case Studies

Generating bills is a ubiquitous task across various domains. Here are a few practical examples:

• Retail Point-of-Sale (POS) Systems: Every time a customer checks out at a grocery store or clothing shop, a bill is generated detailing their purchases.
• Restaurant Management Systems: Bills are created for dining customers, listing food items, drinks, and the total cost.
• Online E-commerce Platforms: After a successful online purchase, an invoice or bill is emailed to the customer, summarizing their order.
• Utility Billing: Monthly bills for electricity, water, or internet services that detail usage and charges.
• Service Providers: Freelancers or consulting firms generate invoices for clients for services rendered.

Solution Approaches

We will explore three different approaches to create a C++ program for printing a bill, ranging from a basic hardcoded version to a more robust, interactive solution using structures.

Approach 1: Simple Console Bill (Basic Hardcoded Items)

This approach demonstrates the absolute simplest way to print a bill by hardcoding item details directly into the program.

• Summary: Manually defines items, quantities, and prices, then calculates and prints the bill.
• Code Example:

// Simple Console Bill
#include <iostream>
#include <iomanip> // Required for formatting output

int main() {
    // Step 1: Define item details
    std::string item1Name = "Laptop";
    int item1Qty = 1;
    double item1Price = 1200.00;

    std::string item2Name = "Mouse";
    int item2Qty = 2;
    double item2Price = 25.00;

    std::string item3Name = "Keyboard";
    int item3Qty = 1;
    double item3Price = 75.00;

    // Step 2: Calculate total for each item
    double item1Total = item1Qty * item1Price;
    double item2Total = item2Qty * item2Price;
    double item3Total = item3Qty * item3Price;

    // Step 3: Calculate Subtotal, Tax, and Grand Total
    double subtotal = item1Total + item2Total + item3Total;
    double taxRate = 0.08; // 8% tax
    double taxAmount = subtotal * taxRate;
    double grandTotal = subtotal + taxAmount;

    // Step 4: Print the bill header
    std::cout << "----------------------------------------\\n";
    std::cout << std::setw(20) << "YOUR RECEIPT\\n";
    std::cout << "----------------------------------------\\n";
    std::cout << std::left << std::setw(15) << "Item"
              << std::right << std::setw(5) << "Qty"
              << std::right << std::setw(10) << "Price"
              << std::right << std::setw(10) << "Total\\n";
    std::cout << "----------------------------------------\\n";

    // Step 5: Print individual item details
    std::cout << std::left << std::setw(15) << item1Name
              << std::right << std::setw(5) << item1Qty
              << std::right << std::setw(10) << std::fixed << std::setprecision(2) << item1Price
              << std::right << std::setw(10) << std::fixed << std::setprecision(2) << item1Total << "\\n";

    std::cout << std::left << std::setw(15) << item2Name
              << std::right << std::setw(5) << item2Qty
              << std::right << std::setw(10) << std::fixed << std::setprecision(2) << item2Price
              << std::right << std::setw(10) << std::fixed << std::setprecision(2) << item2Total << "\\n";

    std::cout << std::left << std::setw(15) << item3Name
              << std::right << std::setw(5) << item3Qty
              << std::right << std::setw(10) << std::fixed << std::setprecision(2) << item3Price
              << std::right << std::setw(10) << std::fixed << std::setprecision(2) << item3Total << "\\n";

    std::cout << "----------------------------------------\\n";

    // Step 6: Print summary totals
    std::cout << std::left << std::setw(25) << "Subtotal:"
              << std::right << std::setw(15) << std::fixed << std::setprecision(2) << subtotal << "\\n";

    std::cout << std::left << std::setw(25) << "Tax (" << (taxRate * 100) << "%):"
              << std::right << std::setw(15) << std::fixed << std::setprecision(2) << taxAmount << "\\n";

    std::cout << "----------------------------------------\\n";

    std::cout << std::left << std::setw(25) << "Grand Total:"
              << std::right << std::setw(15) << std::fixed << std::setprecision(2) << grandTotal << "\\n";
    std::cout << "----------------------------------------\\n";
    std::cout << "Thank You!\\n";

    return 0;
}

Run

• Sample Output:

----------------------------------------
             YOUR RECEIPT
----------------------------------------
Item              Qty   Price      Total
----------------------------------------
Laptop             1  1200.00  1200.00
Mouse              2    25.00    50.00
Keyboard           1    75.00    75.00
----------------------------------------
Subtotal:                    1325.00
Tax (8.00%):                   106.00
----------------------------------------
Grand Total:                 1431.00
----------------------------------------
Thank You!

• Stepwise Explanation:

1. Define Item Details: Individual variables are used to store the name, quantity, and price for each item.
2. Calculate Item Totals: The total cost for each item is calculated by multiplying its quantity and price.
3. Calculate Summaries: subtotal, taxAmount (based on a defined taxRate), and grandTotal are computed.
4. Print Header: std::cout statements, along with std::setw (set width), std::left, std::right, std::fixed, and std::setprecision from , are used to format the header and column titles.
5. Print Item Details: Each item's details and its calculated total are printed in a formatted row.
6. Print Summary Totals: The subtotal, tax, and grand total are displayed at the bottom of the bill.

Approach 2: Interactive Bill Generation (User Input)

This approach allows the user to input details for multiple items, making the bill generation dynamic.

• Summary: Uses a loop to accept multiple item inputs from the user, then calculates and displays the bill.
• Code Example:

// Interactive Bill Generator
#include <iostream>
#include <vector>   // For std::vector
#include <string>   // For std::string
#include <iomanip>  // For formatting

struct BillItem {
    std::string name;
    int quantity;
    double price;
    double total;
};

int main() {
    // Step 1: Initialize variables
    std::vector<BillItem> items;
    double subtotal = 0.0;
    char addMore = 'y';
    int itemCounter = 1;

    // Step 2: Loop to get item details from user
    while (addMore == 'y' || addMore == 'Y') {
        BillItem currentItem;
        std::cout << "\\nEnter details for Item " << itemCounter << ":\\n";
        std::cout << "Enter item name: ";
        std::cin.ignore(); // Consume the newline character left by previous cin
        std::getline(std::cin, currentItem.name);

        std::cout << "Enter quantity: ";
        std::cin >> currentItem.quantity;

        std::cout << "Enter price per item: $";
        std::cin >> currentItem.price;

        currentItem.total = currentItem.quantity * currentItem.price;
        items.push_back(currentItem);
        subtotal += currentItem.total;

        std::cout << "Add another item? (y/n): ";
        std::cin >> addMore;
        itemCounter++;
    }

    // Step 3: Calculate Tax and Grand Total
    double taxRate = 0.08; // 8% tax
    double taxAmount = subtotal * taxRate;
    double grandTotal = subtotal + taxAmount;

    // Step 4: Print the bill
    std::cout << "\\n----------------------------------------\\n";
    std::cout << std::setw(20) << "YOUR RECEIPT\\n";
    std::cout << "----------------------------------------\\n";
    std::cout << std::left << std::setw(15) << "Item"
              << std::right << std::setw(5) << "Qty"
              << std::right << std::setw(10) << "Price"
              << std::right << std::setw(10) << "Total\\n";
    std::cout << "----------------------------------------\\n";

    // Step 5: Print individual item details from vector
    for (const auto& item : items) {
        std::cout << std::left << std::setw(15) << item.name
                  << std::right << std::setw(5) << item.quantity
                  << std::right << std::setw(10) << std::fixed << std::setprecision(2) << item.price
                  << std::right << std::setw(10) << std::fixed << std::setprecision(2) << item.total << "\\n";
    }
    std::cout << "----------------------------------------\\n";

    // Step 6: Print summary totals
    std::cout << std::left << std::setw(25) << "Subtotal:"
              << std::right << std::setw(15) << std::fixed << std::setprecision(2) << subtotal << "\\n";

    std::cout << std::left << std::setw(25) << "Tax (" << (taxRate * 100) << "%):"
              << std::right << std::setw(15) << std::fixed << std::setprecision(2) << taxAmount << "\\n";

    std::cout << "----------------------------------------\\n";

    std::cout << std::left << std::setw(25) << "Grand Total:"
              << std::right << std::setw(15) << std::fixed << std::setprecision(2) << grandTotal << "\\n";
    std::cout << "----------------------------------------\\n";
    std::cout << "Thank You!\\n";

    return 0;
}

Run

• Sample Output:

Enter details for Item 1:
Enter item name: Apple
Enter quantity: 2
Enter price per item: $1.50
Add another item? (y/n): y

Enter details for Item 2:
Enter item name: Orange
Enter quantity: 3
Enter price per item: $0.75
Add another item? (y/n): n

----------------------------------------
             YOUR RECEIPT
----------------------------------------
Item              Qty   Price      Total
----------------------------------------
Apple              2     1.50     3.00
Orange             3     0.75     2.25
----------------------------------------
Subtotal:                      5.25
Tax (8.00%):                   0.42
----------------------------------------
Grand Total:                   5.67
----------------------------------------
Thank You!

• Stepwise Explanation:

1. Define BillItem Structure: A struct BillItem is introduced to group related data (name, quantity, price, total) for a single item, improving code organization.
2. Initialize std::vector: A std::vector called items is used to dynamically store all items the user enters. subtotal is also initialized.
3. Loop for User Input: A while loop continuously prompts the user to enter item name, quantity, and price.
   • std::cin.ignore() is used before std::getline to clear the buffer of any leftover newline characters from previous std::cin operations, ensuring getline reads correctly.

1. Calculate Totals: Similar to Approach 1, tax and grand total are calculated based on the accumulated subtotal.
2. Print Bill: The structure and formatting for printing the bill remain similar, but now a for loop iterates through the items vector to print each item's details.

Approach 3: Using Functions for Modularity (More Organized)

This approach refactors the interactive solution into functions to improve modularity and readability, a common practice in larger programs.

• Summary: Divides the bill generation logic into distinct functions for getting input, calculating totals, and printing, using a struct for item data.
• Code Example:

// Modular Bill Generator
#include <iostream>
#include <vector>
#include <string>
#include <iomanip>

// Define a structure for an item
struct BillItem {
    std::string name;
    int quantity;
    double price;
    double itemTotal; // Total for this specific item
};

// Function to get item details from user
void getItemDetails(BillItem& item, int itemCounter) {
    std::cout << "\\nEnter details for Item " << itemCounter << ":\\n";
    std::cout << "Enter item name: ";
    std::cin.ignore(); // Consume the newline character left by previous cin
    std::getline(std::cin, item.name);

    std::cout << "Enter quantity: ";
    std::cin >> item.quantity;

    std::cout << "Enter price per item: $";
    std::cin >> item.price;

    item.itemTotal = item.quantity * item.price;
}

// Function to calculate all totals
void calculateTotals(const std::vector<BillItem>& items, double& subtotal, double& taxAmount, double& grandTotal, double taxRate = 0.08) {
    subtotal = 0.0;
    for (const auto& item : items) {
        subtotal += item.itemTotal;
    }
    taxAmount = subtotal * taxRate;
    grandTotal = subtotal + taxAmount;
}

// Function to print the entire bill
void printBill(const std::vector<BillItem>& items, double subtotal, double taxAmount, double grandTotal, double taxRate = 0.08) {
    std::cout << "\\n----------------------------------------\\n";
    std::cout << std::setw(20) << "YOUR RECEIPT\\n";
    std::cout << "----------------------------------------\\n";
    std::cout << std::left << std::setw(15) << "Item"
              << std::right << std::setw(5) << "Qty"
              << std::right << std::setw(10) << "Price"
              << std::right << std::setw(10) << "Total\\n";
    std::cout << "----------------------------------------\\n";

    for (const auto& item : items) {
        std::cout << std::left << std::setw(15) << item.name
                  << std::right << std::setw(5) << item.quantity
                  << std::right << std::setw(10) << std::fixed << std::setprecision(2) << item.price
                  << std::right << std::setw(10) << std::fixed << std::setprecision(2) << item.itemTotal << "\\n";
    }
    std::cout << "----------------------------------------\\n";

    std::cout << std::left << std::setw(25) << "Subtotal:"
              << std::right << std::setw(15) << std::fixed << std::setprecision(2) << subtotal << "\\n";

    std::cout << std::left << std::setw(25) << "Tax (" << (taxRate * 100) << "%):"
              << std::right << std::setw(15) << std::fixed << std::setprecision(2) << taxAmount << "\\n";

    std::cout << "----------------------------------------\\n";

    std::cout << std::left << std::setw(25) << "Grand Total:"
              << std::right << std::setw(15) << std::fixed << std::setprecision(2) << grandTotal << "\\n";
    std::cout << "----------------------------------------\\n";
    std::cout << "Thank You!\\n";
}

int main() {
    std::vector<BillItem> items;
    double subtotal = 0.0;
    double taxAmount = 0.0;
    double grandTotal = 0.0;
    double taxRate = 0.08;
    char addMore = 'y';
    int itemCounter = 1;

    // Loop to get item details
    while (addMore == 'y' || addMore == 'Y') {
        BillItem currentItem;
        getItemDetails(currentItem, itemCounter); // Call function to get details
        items.push_back(currentItem);

        std::cout << "Add another item? (y/n): ";
        std::cin >> addMore;
        itemCounter++;
    }

    // Calculate all totals using a function
    calculateTotals(items, subtotal, taxAmount, grandTotal, taxRate);

    // Print the bill using a function
    printBill(items, subtotal, taxAmount, grandTotal, taxRate);

    return 0;
}

Run

• Sample Output: (Same as Approach 2, as the logic is similar, just structured differently.)

Enter details for Item 1:
Enter item name: Pen
Enter quantity: 5
Enter price per item: $1.20
Add another item? (y/n): y

Enter details for Item 2:
Enter item name: Notebook
Enter quantity: 2
Enter price per item: $3.50
Add another item? (y/n): n

----------------------------------------
             YOUR RECEIPT
----------------------------------------
Item              Qty   Price      Total
----------------------------------------
Pen                5     1.20     6.00
Notebook           2     3.50     7.00
----------------------------------------
Subtotal:                     13.00
Tax (8.00%):                   1.04
----------------------------------------
Grand Total:                  14.04
----------------------------------------
Thank You!

• Stepwise Explanation:

1. Define BillItem Structure: Remains the same as in Approach 2.
2. getItemDetails Function: This function takes a BillItem object by reference and an itemCounter to prompt the user for item-specific details. It calculates itemTotal for that item.
3. calculateTotals Function: This function takes the vector of BillItems, and references to subtotal, taxAmount, and grandTotal. It iterates through the items to compute these summary totals.
4. printBill Function: This function is responsible solely for formatting and printing the entire bill, taking all necessary item details and calculated totals as constant references.
5. main Function: The main function now acts as an orchestrator, calling these specialized functions in sequence to gather input, perform calculations, and display the bill. This makes main much cleaner and easier to understand.

Conclusion

Creating a C++ program to print a bill involves defining items, calculating costs, and formatting the output. We started with a basic hardcoded example, moved to an interactive version using user input and a std::vector, and finally structured the code with functions for better modularity. Each approach built upon the previous one, demonstrating how to handle increasing complexity and improve code organization.

Summary

• Basic Bill Generation: Can be achieved by hardcoding item details and using std::cout with iomanip for formatting.
• Interactive Input: Using std::cin within a loop allows for dynamic input of multiple items.
• Data Structures: A struct (e.g., BillItem) effectively groups related data for each item.
• Dynamic Storage: std::vector is suitable for storing a variable number of items.
• Modularity: Breaking down the program into functions (e.g., getItemDetails, calculateTotals, printBill) enhances readability, maintainability, and reusability of code.
• Formatting: std::setw, std::left, std::right, std::fixed, and std::setprecision from are essential for clear, tabular output.