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

Learning Objectives

• Ownership
• Ownership Rules
• Drop and Copy traits

System Requirements

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

Prerequisites

Code Files

• The following code file is required to practise this tutorial.
• Ownership.rs
• This file is provided in theCode Files link of this tutorial page.

Ownership

• Ownership allows memory safety without a garbage collector.
• It is a key feature of Rust language that allows it to be both safe and fast.

Ownership Rules

• Each value in Rust has a single owner
• There can be only one owner at a time
• When the owner goes out of scope the value will be dropped.

Drop trait

• To understand the ownership rules, we need to note two traits:
• drop and copy
• These traits are fundamental traits related to resource management and memory handling.

'>'cargo newOwnership

In the menu bar, File >> Open folder >> Desktop

>> MyRustProject >> Ownership

Type the command cargo new Ownership and pressEnter.

Open the created project as shown.

data: String,

}

//highlight impl Drop for MyStruct

impl Drop for MyStruct {

fn drop(&mut self) {

println!("Dropping MyStruct with data: {}", self.data);

}

}

fn main() {

println!("Start");

{

let new_struct = MyStruct {

data: String::from("Hello, world!"),

};

}

println!("End");

// my_struct goes out of scope here, and the drop method is called.

}

Here wecreated a'struct'MyStruct which contains data ofstring type.

In the implementation block,the drop trait forMystruct has been implemented.

The drop method is automatically called when an object goes out of scope.

In the main program,new_struct is created with "Hello, world!" stored in its data.

Here,new_structowns that string.

At the end of the inner scope,new_struct goes out of scope.

Rust automatically callsdrop(&mut self) fornew_struct.

In this code, drop happens before "End" is printed.

This is because the struct’s scope ends earlier.

Save the program.

Clear the code window and copy paste the code from theCode file.

let x = 10;

let y = x; // x is copied, not moved

println!("x: {}, y: {}", x, y); // x is still accessible

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

letv = s; // Move occurs, `s` is no longer valid

// println!("{}", s); // This would cause an error

}

For simple types like i32, boolean, char, etc., Rustcopies the value instead of moving it.

These data types are entirely stored on the stack.

It has a fixed size known at compile time.

After copying, both x and y hold the value 10.

But for the string, the variable s is assigned the value “Hello World!”.

Variable v is assigned to s.

Here,copy doesn’t happen because of String being an owned type.

This fails because after the move,s no longer owns any valid data.

Rust’s compiler prevents you from using s here.

Hence it would show an error.

We can see the copy trait is implemented by default forinteger.

For string type we get an error.

Types likeString or other heap-allocated structures do not implement Copy by default.

println!("s: {},v: {}", s,v); // both accessible

Let's add the clone method as s.clone() in the code.

.clone() method makes an explicit deep copy of the heap data.

Change the print statement to print s and v.

Save the program.

Summary

Let us summarize.

Assignment

• Creates a String variable called greeting with the value "Hello, Rust!".
• Passes it to a function takes_ownership that prints the value.
• Inside this function, remember that ownership is moved.

Thank You