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

Title Slide

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.

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 to create and run the project.

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 the modified values are printed successfully.

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

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

Press Ctrl + S to save the file.

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.

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 Type

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

fn main() { let x: i32 = 100; let y: u32 = 200; let f: f64 = 3.14; let flag: bool = true; let character: char = 'R'; println!("Integer: {}", x); println!("Integer: {}", y); println!("Float: {}", f); println!("Boolean: {}", flag); println!("Character: {}", character);

}

i specifies signed integer type that is, it can store both positive or negative value.

32 is the size of the data type that is, it takes 32 bits of space in memory.

Integers can be of many types as i8, i16, i32, i64.

u specifies the unsigned integer type that is, it can only store positive integer values.

If we try to store negative numbers to u32 type variables, we will get an error.

Here, the f character represents a floating point number.

32 and 64 represent the size in bits.

A boolean data type can have two possible values: true or false.

char represents the character type variable and we use single quotes to represent a character.

We can also store special characters like $ and & using the character type.

Save the program.

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 const PI: f32 = 3.14159265358979323846; fn main() { let radius = 5.0; let circumference = 2.0 * PI * radius; println!("The circumference of a circle with radius {} is {}", radius, circumference); }

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

Forum for specific questions

Acknowlegdements

Thank You

Thank you for joining.