In Rust, input and output operations are primarily handled through the std::io module. Rust provides robust and type-safe mechanisms for interacting with the standard input, output, and error streams.

Output in Rust

Output is generally performed using macros like print! and println!.

Basic Output Examples

  1. Printing a Line:

fn main() {
    println!("Hello, world!"); // Prints with a newline
}
  1. Formatted Output:

fn main() {
    let name = "Alice";
    let age = 25;
    println!("Name: {}, Age: {}", name, age); // String interpolation
}
  1. Printing Without a Newline:

fn main() {
    print!("This is on the same line.");
    print!(" Still on the same line.");
}

Input in Rust

Reading input is usually done via the std::io module, specifically with std::io::stdin.

Basic Input Example


use std::io;

fn main() {
    let mut input = String::new(); // Create a mutable String to store input

    println!("Enter your name:");
    io::stdin()
        .read_line(&mut input) // Read a line from standard input
        .expect("Failed to read line"); // Handle potential errors

    println!("Hello, {}!", input.trim()); // `trim` removes trailing newline
}

Explanation:

  1. io::stdin() accesses the standard input.
  2. read_line(&mut input) reads user input into the mutable input variable.
  3. .expect() handles errors during input operations.
  4. .trim() removes trailing whitespace or newline characters.

Reading Numeric Input

Reading numbers requires parsing the input string, as stdin reads all input as text.


use std::io;

fn main() {
    let mut input = String::new();
    println!("Enter a number:");

    io::stdin()
        .read_line(&mut input)
        .expect("Failed to read line");

    let number: i32 = input
        .trim()
        .parse()
        .expect("Please enter a valid number"); // Convert string to integer

    println!("You entered: {}", number);
}

Explanation:

  • input.trim() ensures no trailing whitespace interferes with parsing.
  • parse() attempts to convert the string into the specified type (i32 here).

File I/O in Rust

Rust supports file handling through the std::fs module.

  1. Writing to a File:

use std::fs::File;
use std::io::Write;

fn main() {
    let mut file = File::create("example.txt").expect("Failed to create file");
    file.write_all(b"Hello, file!").expect("Failed to write to file");
}
  1. Reading from a File:

use std::fs;

fn main() {
    let content = fs::read_to_string("example.txt").expect("Failed to read file");
    println!("File content: {}", content);
}

Summary

OperationFunction/MethodExample
Print Outputprintln!, print!println!("Hello, {}!", name);
Read Inputio::stdinio::stdin().read_line(&mut input);
File OutputFile::create, write_allWrite text to a file
File Inputfs::read_to_stringRead the entire content of a file into a string

Rust's approach to I/O is type-safe, efficient, and well-integrated into its error-handling mechanisms, ensuring robust and reliable code.

Comments

Post a Comment

Popular posts from this blog

Image
In Go, the switch statement is a control structure that allows you to execute one of several code blocks based on the value of an expression. It’s a more efficient and cleaner alternative to using multiple if-else statements, especially when you need to check multiple conditions. Go’s switch statement is powerful and flexible, and it can be used for simple comparisons, type assertions, and even with expressions that return multiple values. Basic Syntax of switch The basic structure of a switch statement in Go is: switch expression { case value1: // Code to execute if expression == value1 case value2: // Code to execute if expression == value2 default : // Code to execute if expression doesn't match any of the cases } Example: package main import "fmt" func main () { day := 3 switch day { case 1 : fmt.Println( "Monday" ) case 2 : fmt.Println( "Tuesday" ) case 3 : fmt.Println(...
Read more
Image
  In Rust, the if statement is used for conditional execution of code. It evaluates a condition, and if the condition is true , the associated block of code is executed. Rust's if statements are versatile and integrate seamlessly with the language's emphasis on safety and expressions. Syntax of if The basic structure of an if statement in Rust is: if condition { // Code to execute if the condition is true } Example: fn main () { let number = 10 ; if number > 5 { println! ( "The number is greater than 5." ); } } if-else Statement You can include an else block to execute code when the condition is false . fn main () { let number = 3 ; if number % 2 == 0 { println! ( "The number is even." ); } else { println! ( "The number is odd." ); } } if-else if Ladder For multiple conditions, you can chain if-else if statements: fn main () { let number = 0 ; if number ...
Read more
Image
  if-else statement helps make decisions in your program. It checks a condition (a true or false statement) and runs code based on whether the condition is true or false. Here’s how it works: If statement : It checks if a condition is true. If the condition is true, the code inside the if block runs. Else statement : If the condition is false, the code inside the else block runs. Example: #include <stdio.h> int main() {     int number = 10;     // Check if number is greater than 5     if (number > 5) {         printf("The number is greater than 5\n");     } else {         printf("The number is 5 or less\n");     }     return 0; } How it works: In this example, the condition is number > 5 . If the number is greater than 5, the program will print "The number is greater than 5". If the number is not greater than 5 (false), the program will print "The number is 5 or less...
Read more