Difference between revisions of "Rust-Programming-Language/C2/Error-Handling/English"

Learning Objectives

• Recoverable Errors
• Unrecoverable Errors and
• Error Propagation Operator

System Requirements

Code Files

• The following code file is required to practise this tutorial.
• This file is provided in the Code Files link of this tutorial page.

Types of Errors

1.Recoverable Errors → These are anticipated failures, handled with Option and Result enums.

2.Unrecoverable Errors → These are unexpected critical failures.

They lead to a panic! and program termination.

'>'cargo new errorhandling

In the menu bar, File >> Open folder.

>> Desktop >> MyRustProject >> errorhandling

Type the command cargo new errorhandling and pressEnter.

Open the created project as shown.

if y == 0.0 {

Err(String::from("Cannot divide by zero"))

} else {

Ok(x / y)

}

}

fn main(){

match divide(10.0, 0.0) {

Ok(result) => println!("Result: {}", result),

Err(e) => println!("Error: {}", e),

}

}

Function divide takes two integers as input parameters and returns the division result.

What happens if we try to divide an integer by zero without handling it?

In Rust, it will cause the program to crash at runtime.

Dividing by zero is a known and anticipated failure.

So we handle it using the Result enum.

If the denominator y is 0, function returns an Err containing an error message.

If the denominator is valid, function returns the successful division wrapped in Ok.

Save the program.

It displays the output as “Cannot divide by zero” as the denominator y is 0 in the code.

Clear the code and Copy paste the code from the code file.

let v = vec![1, 2, 3];

println!("{}", v[99]); // panics: index out of bounds

panic!("Something went terribly wrong!");

}

That is something we do not anticipate and cannot recover from.

We have declared a vector v with three elements.

In this program, it tries to access the element at index 99, which does not exist.

After a panic, the program stops execution, it does not continue to the next line.

Save the program.

Let us run the program

The program prints an error message and the current thread stops.

The panic statement is not executed because the program already panics at the previous line.

Error Propagation Operator (?)

• Error Propagation Operator (?} automatically returns an error if a function call fails.
• This operator can be only used in functions where it returns option or result enum.

Copy and paste the code from the code file.

use std::io::{self, Read};

fn read_file(filename: &str) -> Result<String, io::Error> {

let mut file = File::open(filename)?;// This will return early if File::open fails

let mut contents = String::new();

file.read_to_string(&mut contents)?;// This will return early if read_to_string fails

Ok(contents)

}

fn main() {

match read_file("hello.txt") {

Ok(content) => println!("File content: {}", content),

Err(e) => println!("Error reading file: {}", e),

}

}

The read_file takes a filename which is of type string slice.

It returns a Result enum with Ok type as String and Err type as input output error.

At the line File::open(filename)?, error propagation operator, it attempts to open the file, with the error propagation operator(?).

If successful, it continues execution with the file handle.

If it fails, it returns the error from the function.

Next we initialise a mutable variable calledcontents.

It is of the typeString object.

read_to_string reads all the bytes of the file till end and appends them to contents.

The error propagation(?) Operator returns the error immediately if it fails.

If everything succeeds, it returns the file content.

In main function, we use match arms to handle results returned byread_file function.

Save the program.

We can see the error message “Error reading file”.

This shows that the file hello.txt is not available.

Summary

Let us summarize.

1. Create hello.txt file and with the text “Welcome to Rust tutorials”

2. Save the file in the error handling folder

3. Run the Error Propagation Operator program and check the output

Thank You