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

Learning Objectives

• Borrowing and
• Rules of borrowing

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.

Borrowing

• Borrowing is the act of creating references to data without taking ownership
• When we borrow a value, we reference its memory address with the &

Borrowing - Example

fn main() {

let s = String::from("hello");

let s1 = &s;

}

• Here ‘s’ owns the string “hello”
• ‘s1’ borrows ‘s’ by reference denoted by &s.

But ownership of the string is still with s.

• s1 is only allowed to read the data
• It will point to the data, making it an immutable reference to s.

Rules of borrowing: Rule 1

1. Any number of Immutable references to a data

• You can have any number of immutable references to a data at the same time.
• Immutable references do not allow modification of the data.

Rules of borrowing: Rule 1

• Any number of read operations are safe, but write operations are not allowed.

> cargo new borrow

In the menu bar, File >> Open folder

>> Desktop >> MyRustProject >> borrow

Type the command cargo new borrow and press Enter.

Open the created project as shown.

let a = String::from("Hello world");

let b = &a;

let c = &a;

let d = &a;

println!("{}", b);

println!("{}", c);

println!("{}", d);

}

When you try to print them, there won't be any errors.

It allows multiple immutable references to a piece of data simultaneously.

Save the program.

Output shows, variable a can have multiple immutable references.

Rules of borrowing: Rule 2

2. Only 1 mutable reference to a data

Clear the previous code. Copy paste the code from the Code file.

let mut s = String::from("Hello ");

let r1 = &mut s;

let r2 = &mut s;

r1.push_str("World"); r2.push_str("Rust");

println!("{}",r1);

println!("{}",r2);

}

Variables r1, r2 are assigned with a mutable reference to s.

When both the references try to modify the data, rust wont allow this.

It will lead to a data race, where the data gets corrupted.

let mut s = String::from("Hello ");

let r1 = &mut s;

//let r2 = &mut s;

r1.push_str("world");

//r2.push_str("Rust");

println!("{}",r1);

//println!("{}",r2);'

}

Let us comment the code, related to the second mutable reference.

Save the program.

Rules of Borrowing: Rule 3

Copy and paste the code from the Code file.

let mut s = String::from("Hello ");

let r1 = &mut s;

// let r2 = &s;

r1.push_str("Rust");

println!("{}", r1);

}

Here r1 is assigned ;">as a mutable reference to s.

">And;"> r2 ;">as ;">an immutable reference to s. 

One reference tries to modify the data while another reference tries to read data.

It will lead to corrupt data because the reference didn’t get out of scope.

It still has the mutable reference and may change the data in the scope.

Comment the line of immutable reference to s;"> ;">as shown.

Save the program.

Hence rust doesn't allow you to break all the above 3 rules.

Copy and paste the code from the code file.

let s = String::from("Hello, Rust!");

&s // ❌ Error: `s` is dropped at the end of this function

} // `s` goes out of scope here, but we're trying to return a reference to it

fn main() {

let r = get_reference(); // Trying to use a reference to `s`, but `s` is already dropped

println!("{}", r);

}

In the next line, it returns a reference to that string.

When the function ends, s goes out of scope, and its heap memory is freed.

Here we are trying to return a reference to this freed memory.

Hence, we will get an error.

When we try to run the main function, it leads to an invalid memory.( a dangling reference).

Save the program.

let s = String::from("Hello, Rust!");'

s // ownership is moved out safely'

} '

Let us modify the program to return a value not the reference.

Remove the & from s.

Save the program.

• Borrowing
• Rules of borrowing

Let us summarize.

Assignment

fn main() {'

let fruit1 = String::from("Apple");'

let fruit2 = fruit1; '

println!("fruit1 = {}", fruit1); '

println!("fruit2 = {}", fruit2);'

}'

Run the above code and fix the error.

Thank You'