Difference between revisions of "Rust-Programming-Language/C2/Variables-and-Mutability/English"

Title Slide

Learning Objective

• Variables and
• Mutability

System Requirements

• Ubuntu Linux OS version 22.04
• Rust 1.80.0
• Visual Studio Code 1.19.0

Prerequisites

• You should be familiar with compiling and running a Rust program

Code Files

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

Variables let a = 10; //immutable let mut b=15;//mutable

• In Rust, we create variables using the let statement.
• By default, variables are immutable,meaning their values cannot be changed
• You can make them mutable by using mut.

Ctrl+Tilde (~)

Click on Terminal and select New Terminal.

We can see a terminal window at the bottom.

cargo new variables

Please refer to the Additional Reading material link of this tutorial. It explains the steps to create and run the project.

Type the command cargo new variables and press Enter

Open the created project as shown.

Press Ctrl + C to copy

Press Ctrl + V to paste

fn main(){

let a = 1;

println!(“The value of a is {}”,a);

a=2;

println!(“The value of a is {}”,a);

}

Here we have initialized the variable a and assigned the value 1 to it.

We are trying to reassign the value 2 to variable a.

After reassigning we are printing the variable’s value to see what the value contains.

Press Ctrl and S to save the file.

Note that we had mentioned variables are immutable by default.

Let mut a=1;

Here we are telling the compiler that the initialized variable is mutable.

In the terminal, type cargo run

Both the initialized and modified values are printed successfully.

Rust allows variable shadowing.

Here the variable x is shadowing.

Shadowing is to declare a new variable with the same name as a previous variable in the same scope.

We can assign a new value to the new variable while the old variable remains unchanged.

Save the file.

Check the output.

It prints the value of x as 5 and 7 as the result of shadowing.

fn main() {

// scope of outer_var variable is inside the main function code block

let outer_var = 100;

// start of the inner code block

{

// scope of inner_var variable is only inside this new code block

let inner_var = 200;

println!("inner_var = {}", inner_var);

}

// end of the inner code block

println!("inner_var = {}", inner_var);

println!("outer_var = {}", outer_var);

}

Copy and paste the code from the code file.

In this code, observe the declaration of variables outer_var and inner_var.

Curly braces { } define the block scope where the variable access becomes restricted to the local.

Save the program.

We can see a compilation error.

Here we tried to print the inner_var outside of the inner code block.

So the program will give an error.

Let us comment the print statement of inner_var in the outer block.

Save the program.

Run the program again to see the output.

We can see the output displayed for outer_var as 100 and inner_var as 200.

This shows that any variable outside the braces will have global access.

Summary

Let us summarize.

Assignment

fn main() {

let x = 10; // Immutable variable

println!("The value of x is: {}", x);

x = 20;

println!("The new value of x is: {}", x);

}

• Run the above program
• Analyse the error and correct the program.

We would like to thank Vishal Pokuri from VIT Vellore for content contribution.

Thank you for joining.