Creating a Simple Calculator in C

Building a calculator in C is a fantastic way to solidify your understanding of fundamental programming concepts. It touches upon user input, conditional logic, basic arithmetic operations, and error handling – all crucial skills for any aspiring C programmer. In this guide, we'll walk through the process of creating a command-line calculator that can perform addition, subtraction, multiplication, and division.

The Core Components of Our Calculator

Every calculator, no matter how complex, needs to perform a few basic functions. Our C calculator will need to:

• Get Input: Acquire two numbers from the user and the desired arithmetic operation.
• Perform Calculation: Apply the chosen operation to the numbers.
• Handle Errors: Graciously manage scenarios like division by zero or invalid input.
• Display Output: Show the result of the calculation to the user.

Step 1: Gathering User Input

First, we need to declare variables to store the two numbers, the operator, and the final result. We'll use float for numbers to handle decimal values and char for the operator. The scanf function will be our tool for reading input from the console.

It's good practice to prompt the user clearly so they know what to enter.

#include <stdio.h> // Required for printf and scanf

int main() {
    float num1, num2, result;
    char operator;

    // Prompt for the first number
    printf("Enter first number: ");
    scanf("%f", &num1);

    // Prompt for the operator
    printf("Enter operator (+, -, *, /): ");
    // Note the space before %c to consume any leftover newline character
    scanf(" %c", &operator); 

    // Prompt for the second number
    printf("Enter second number: ");
    scanf("%f", &num2);

    // Calculations will go here later...

    return 0;
}
    

Step 2: Performing Calculations with the switch Statement

The switch statement is ideal for handling multiple possible operations based on a single character (our operator). For each valid operator, we'll perform the corresponding arithmetic and store the result. We'll also include a default case to catch any invalid operators.

// ... (previous code)

    switch (operator) {
        case '+':
            result = num1 + num2;
            printf("%.2f + %.2f = %.2f\n", num1, num2, result);
            break; // Exit the switch statement
        case '-':
            result = num1 - num2;
            printf("%.2f - %.2f = %.2f\n", num1, num2, result);
            break;
        case '*':
            result = num1 * num2;
            printf("%.2f * %.2f = %.2f\n", num1, num2, result);
            break;
        case '/':
            // Division by zero check will be added in the next step
            result = num1 / num2;
            printf("%.2f / %.2f = %.2f\n", num1, num2, result);
            break;
        default:
            printf("Error: Invalid operator entered.\n");
    }

// ... (return 0;)
    

Step 3: Robustness through Error Handling (Division by Zero)

A professional calculator must handle edge cases. The most common one for a basic calculator is division by zero. If the second number (denominator) is zero and the operation is division, our program should issue an error message instead of crashing or returning an undefined value. We'll implement this check within the '/' case of our switch statement.

// ... (previous code)

    switch (operator) {
        case '+':
            result = num1 + num2;
            printf("%.2f + %.2f = %.2f\n", num1, num2, result);
            break;
        case '-':
            result = num1 - num2;
            printf("%.2f - %.2f = %.2f\n", num1, num2, result);
            break;
        case '*':
            result = num1 * num2;
            printf("%.2f * %.2f = %.2f\n", num1, num2, result);
            break;
        case '/':
            if (num2 == 0) {
                printf("Error: Division by zero is not allowed.\n");
            } else {
                result = num1 / num2;
                printf("%.2f / %.2f = %.2f\n", num1, num2, result);
            }
            break;
        default:
            printf("Error: Invalid operator entered.\n");
    }

// ... (return 0;)
    

Step 4: Making it Interactive (Looping for Multiple Calculations)

To make our calculator more user-friendly, we can allow the user to perform multiple calculations without restarting the program. A do-while loop is perfect for this. It ensures at least one calculation is performed and then prompts the user if they wish to continue.

#include <stdio.h>

int main() {
    float num1, num2, result;
    char operator;
    char choice; // To store user's choice to continue or exit

    do {
        // Prompt for the first number
        printf("Enter first number: ");
        scanf("%f", &num1);

        // Prompt for the operator
        printf("Enter operator (+, -, *, /): ");
        scanf(" %c", &operator); // Space before %c to consume newline

        // Prompt for the second number
        printf("Enter second number: ");
        scanf("%f", &num2);

        switch (operator) {
            case '+':
                result = num1 + num2;
                printf("%.2f + %.2f = %.2f\n", num1, num2, result);
                break;
            case '-':
                result = num1 - num2;
                printf("%.2f - %.2f = %.2f\n", num1, num2, result);
                break;
            case '*':
                result = num1 * num2;
                printf("%.2f * %.2f = %.2f\n", num1, num2, result);
                break;
            case '/':
                if (num2 == 0) {
                    printf("Error: Division by zero is not allowed.\n");
                } else {
                    result = num1 / num2;
                    printf("%.2f / %.2f = %.2f\n", num1, num2, result);
                }
                break;
            default:
                printf("Error: Invalid operator entered.\n");
        }

        // Ask user if they want to perform another calculation
        printf("\nDo you want to perform another calculation? (y/n): ");
        scanf(" %c", &choice); // Space before %c for newline

    } while (choice == 'y' || choice == 'Y'); // Loop continues if 'y' or 'Y'

    printf("Calculator program terminated. Goodbye!\n");

    return 0;
}
    

The Complete C Calculator Code

Here's the consolidated, ready-to-run code for our simple interactive calculator.

#include <stdio.h> // Standard input/output library

int main() {
    float num1, num2, result; // Variables to store numbers and result (using float for decimals)
    char operator;            // Variable to store the arithmetic operator
    char choice;              // Variable to store user's choice to continue/exit

    // Start a do-while loop to allow multiple calculations
    do {
        printf("\n--- Simple C Calculator ---\n");

        // Step 1: Get the first number from the user
        printf("Enter first number: ");
        if (scanf("%f", &num1) != 1) { // Check if input was successful
            printf("Invalid input. Please enter a number.\n");
            // Clear input buffer to prevent infinite loop on bad input
            while (getchar() != '\n'); 
            continue; // Skip to next iteration
        }

        // Step 2: Get the operator from the user
        printf("Enter operator (+, -, *, /): ");
        scanf(" %c", &operator); // Note the space before %c to consume leftover newline

        // Step 3: Get the second number from the user
        printf("Enter second number: ");
        if (scanf("%f", &num2) != 1) { // Check if input was successful
            printf("Invalid input. Please enter a number.\n");
            // Clear input buffer
            while (getchar() != '\n');
            continue; // Skip to next iteration
        }

        // Step 4: Perform calculation using a switch statement
        switch (operator) {
            case '+':
                result = num1 + num2;
                printf("Result: %.2f + %.2f = %.2f\n", num1, num2, result);
                break;
            case '-':
                result = num1 - num2;
                printf("Result: %.2f - %.2f = %.2f\n", num1, num2, result);
                break;
            case '*':
                result = num1 * num2;
                printf("Result: %.2f * %.2f = %.2f\n", num1, num2, result);
                break;
            case '/':
                // Step 5: Implement error handling for division by zero
                if (num2 == 0) {
                    printf("Error: Division by zero is not allowed.\n");
                } else {
                    result = num1 / num2;
                    printf("Result: %.2f / %.2f = %.2f\n", num1, num2, result);
                }
                break;
            default:
                // Handle invalid operators
                printf("Error: Invalid operator entered. Please use +, -, *, or /.\n");
        }

        // Ask the user if they want to perform another calculation
        printf("\nDo you want to perform another calculation? (y/n): ");
        scanf(" %c", &choice); // Space before %c for reading choice character

    } while (choice == 'y' || choice == 'Y'); // Continue loop if user enters 'y' or 'Y'

    printf("Calculator program terminated. Goodbye!\n"); // Farewell message

    return 0; // Indicate successful execution
}
    

Code Breakdown

• #include <stdio.h>: This line includes the standard input/output library, providing functions like printf (for printing to console) and scanf (for reading input from console).
• Variable Declarations:
  • float num1, num2, result;: Declares three variables of type float to hold floating-point numbers. This allows us to work with decimals.
  • char operator;: Declares a character variable to store the arithmetic operator (+, -, *, /).
  • char choice;: Declares a character variable to store the user's decision to continue or exit the calculator.
• do-while Loop:
  • The entire calculation logic is wrapped in a do-while loop.
  • do { ... }: Ensures the calculator runs at least once.
  • while (choice == 'y' || choice == 'Y');: The loop continues as long as the user enters 'y' or 'Y' when asked if they want another calculation.
• scanf("%f", &num1);: Reads a floating-point number from the user and stores it in num1. The & is the "address-of" operator, passing the memory address of num1 to scanf.
• scanf(" %c", &operator);: Reads a single character (the operator). The space before %c is crucial. It tells scanf to consume any leftover whitespace characters (like the newline character from the previous scanf) before reading the actual character input. This prevents unexpected behavior.
• Input Validation (if (scanf(...) != 1)): We've added basic input validation for numbers. If scanf doesn't successfully read 1 item (a float), it means the user entered non-numeric input. We print an error, clear the input buffer with while (getchar() != '\n');, and use continue to restart the loop.
• switch (operator) { ... }: This control statement checks the value of the operator variable.
  • case '+':: If operator is '+', the code inside this block executes.
  • break;: After an operation is performed, break exits the switch statement, preventing "fall-through" to other cases.
  • case '/': with if (num2 == 0): This demonstrates error handling. Before performing division, it checks if num2 is zero. If it is, an error message is printed; otherwise, the division proceeds.
  • default:: If the operator doesn't match any of the case values, the code in the default block executes, informing the user of an invalid operator.
• printf("Result: %.2f ...", num1, num2, result);: Prints the result. %.2f formats the floating-point numbers to display only two decimal places, making the output cleaner.

Conclusion and Next Steps

Congratulations! You've successfully built a functional, interactive command-line calculator in C. This project has reinforced key programming concepts such as variable declaration, user input, conditional logic, and error handling.

From here, you can expand your calculator's capabilities:

• More Functions: Add support for modulo (%), exponentiation (pow from <math.h>), square root, or trigonometric functions.
• Operator Precedence: Implement logic to handle expressions like 2 + 3 * 4 correctly (multiplication before addition). This usually involves converting infix expressions to postfix (RPN) and then evaluating.
• Complex Expressions: Allow users to type entire expressions (e.g., "5 + 6 / 2 - 1"). This would require more advanced parsing techniques.
• Memory Functionality: Add 'M+' 'M-' 'MR' 'MC' buttons (or commands).
• Graphical User Interface (GUI): Move beyond the command line and create a visual interface using libraries like GTK or SDL.

Keep experimenting and happy coding!