Скачать или смотреть Understanding Mutable and Immutable References in Rust: A Deep Dive into Borrowing Rules

Explore why Rust allows two borrow variables within the same scope—one mutable and another immutable. Gain a deeper understanding of Rust's borrowing rules and how they enhance memory safety.
---
This video is based on the question https://stackoverflow.com/q/73927952/ asked by the user 'Palash Kanti Kundu' ( https://stackoverflow.com/u/5571236/ ) and on the answer https://stackoverflow.com/a/73928281/ provided by the user 'Silvio Mayolo' ( https://stackoverflow.com/u/2288659/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: Why am I able to make two borrow variables within the same scope one with mutable reference and the other with immutable reference?

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Understanding Mutable and Immutable References in Rust: A Deep Dive into Borrowing Rules

Rust is a system programming language that puts a lot of emphasis on memory safety without using a garbage collector. One of the cornerstones of this safety is its borrowing rules. A common question that beginners encounter is: Why am I able to make two borrow variables within the same scope—one with a mutable reference and another with an immutable reference? Let's break this down and clarify this confusing aspect.

The Borrowing Rules in Rust

As you've already noted, Rust has specific rules governing how references can be borrowed:

One mutable reference: You can have only one mutable reference to a piece of data in a given scope.

Multiple immutable references: You can have as many immutable references as you like—but, if you have a mutable reference, you cannot have any immutable references at the same time.

This can lead to confusion, especially when you find that your program seems to work despite seemingly breaking these rules.

Analyzing the Code Example

Let's take a closer look at the code you provided:

[[See Video to Reveal this Text or Code Snippet]]

Key Observations

Mutable Reference:

You created a mutable reference d with let d = &mut s;.

This mutable reference is used to modify the string.

Immutable Reference:

You also created an immutable reference f with let f = &s;.

This reference is for reading the string.

What Happens When You Uncomment Lines?

If you uncomment the lines print(d); or change_string(d);, the compiler will raise an error. This is because you are trying to hold onto both references at the same time, which violates Rust's borrowing rules.

Rust's Smart Compiler

So why does the current code work? This is where Rust's clever compiler plays its role. When you declare the immutable reference f, Rust sees that the mutable reference d is never used again in the code. So, it effectively considers d as going out of scope before introducing f.

This implicit dropping of d before declaring f allows both references to coexist without violating the borrowing rules. The compiler does this by inserting a drop(d); behind the scenes, giving you the expected behavior without the program crashing or behaving unpredictably.

Conclusion

Understanding borrow semantics in Rust may seem daunting at first, but it’s essential for writing safe and efficient code. By recognizing that:

You can borrow either one mutable reference or multiple immutable references, but never both simultaneously.

Rust's compiler is designed to enforce these rules while also being smart enough to determine the lifetime of variables.

You can write better code with confidence, knowing that Rust is always watching out for memory safety.

If you’re still unclear about borrowing in Rust, don’t hesitate to delve deeper into the documentation and practice with more code examples. Happy coding!