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

Learning Objective

• Variables
• Mutability and
• Data types

System Requirements

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

Prerequisites

https://spoken-tutorial.org

• You should be familiar with compiling and running a Rust program
• If not, please go through the prerequisite Rust tutorial on this website.

Code Files

• The files used in this tutorial are provided in the Code files link of this tutorial page
• Please download and extract the files.
• Make a copy and then use them while practicing.

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.

Click on Terminal and select New Terminal.

We can see a terminal window at the bottom.

Type at the prompt:

cargo new variables

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.

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.

In the terminal, type cargo run

Both the initialized and the modified values are printed successfully.

fn main() { let x = 5; println!("x is {}", x);

let x = x + 2; println!("x is {}", x); }

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 codefile.

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 local.

Save the program.

Rust - Data types

• Every value in Rust is of a certain Type.
• Rust is a statically typed language that checks the types of variables at compile time.
• Compiler must know the type of all variables at compile time
• This helps the compiler to optimize for efficient and faster runtime execution.

• Scalar and Compound Types

A Scalar Type is referred to as a single value. Rust has four Scalar Data types. They are

• Integers
• Float
• Boolean
• Character

Copy paste the code from the code file.

We can see the various data types printed as output.

Type Inference in Rust

• In Rust we can create variables without mentioning a data type
• let x=50;
• Rust will automatically set i32 as default type for integer by looking at the value 50.
• This process is Type Inference.

Constants

• Constants are variables that are immutable and have a fixed value.
• They are declared using the const keyword.
• You must declare the type of the value.

Let us summarize.

Summary

• Variables
• Mutability and
• Data types

Assignment

fn main() { let y: u32 = - 200; println!("Integer: {}", y); }

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

About Spoken Tutorial Project

Please download and watch it.

Spoken Tutorial Workshops

For more details, please write to us.

Thank you for joining.