Exceptions & Errors

Overview

Definition

Exception handling is a mechanism in programming languages that deals with runtime errors and exceptional situations. It allows you to gracefully handle errors and continue execution rather than crashing the program.

Use Cases

Exception handling is used in scenarios where unexpected situations can arise, such as file I/O errors, network communication issues, or arithmetic errors.

Pros & Cons

👍

Readability

Improves code readability by separating error-handling logic from main program flow.

Structured

Provides a structured way to handle errors and recover gracefully.

Robust & Reliability

Enhances program robustness and reliability by preventing crashes due to unexpected errors.

👎

Overhead

Can introduce performance overhead when exceptions are thrown frequently.

Convoluted Code

Overuse of exceptions can lead to convoluted code and reduced maintainability.

Exception & Error Handling Syntax

Pseudocode

BEGIN
    TRY
        Read userInput
        Convert userInput to integer
        PRINT "You entered:", userInput
    CATCH InvalidInputException
        PRINT "Invalid input! Please enter a valid integer."
    CATCH Exception
        PRINT "An unexpected error occurred."
    END TRY
END

C++

#include <iostream>
using namespace std;

int main() {
    try {
        int userInput;
        cin >> userInput;
        if (cin.fail()) {
            throw runtime_error("Invalid input! Please enter a valid integer.");
        }
        cout << "You entered: " << userInput << endl;
    }
    catch (const exception &e) {
        cerr << e.what() << endl;
    }
    return 0;
}

Python

def main():
    try:
        user_input = int(input("Enter an integer: "))
        print("You entered:", user_input)
    except ValueError:
        print("Invalid input! Please enter a valid integer.")
    except Exception as e:
        print("An unexpected error occurred.")


if __name__ == "__main__":
    main()

Java

import java.util.Scanner;

public class ErrorHandlingDemo {
    public static void main(String[] args) {
        try {
            Scanner scanner = new Scanner(System.in);
            int userInput = scanner.nextInt();
            System.out.println("You entered: " + userInput);
        } catch (java.util.InputMismatchException e) {
            System.err.println("Invalid input! Please enter a valid integer.");
        } catch (Exception e) {
            System.err.println("An unexpected error occurred.");
        }
    }
}

Rust

use std::io;

fn main() {
    let mut user_input = String::new();
    io::stdin().read_line(&mut user_input).expect("Failed to read input");
    match user_input.trim().parse::<i32>() {
        Ok(num) => println!("You entered: {}", num),
        Err(_) => println!("Invalid input! Please enter a valid integer."),
    }
}

Golang

package main

import (
	"fmt"
	"strconv"
)

func main() {
	var userInput string
	fmt.Print("Enter an integer: ")
	fmt.Scan(&userInput)
	num, err := strconv.Atoi(userInput)
	if err == nil {
		fmt.Println("You entered:", num)
	} else {
		fmt.Println("Invalid input! Please enter a valid integer.")
	}
}

Output

In each, a user-entered value is validated through error / exception handling. The exception [error] is thrown when the validation fails.

Note: Various means of evaluation are available per language with a range of validation abilities

Outcomes will vary based on the exception throw and or error caught...

Compare & Contrast

Language	Methodology	Comments/Notes
C++	Exception-based with try and catch blocks	Utilizes standard exceptions for error handling.
Python	Exception-based using try and except clauses	Python’s concise syntax simplifies error handling.
Java	Exception-based with try, catch, and throw	Strongly typed exceptions offer clear error identification.
Rust	Result-based approach with Result and match	Forces explicit handling of success or error cases.
Go	Return value-based with error returns and if checks	Simplicity in error handling with multiple return values.