Mutable References क्या हैं
In this page:
let mut value = data;
let r = &mut value;
*r = new_value;
fn name(param: &mut Type) {}Creating a Mutable Reference
&mut value लिखना एक reference बनाता है जो इसके point किए गए data को modify करने की अनुमति है। Referenced किया जा रहा variable खुद mut से declare किया गया होना चाहिए।
उदाहरण: Creating a Mutable Reference
// Define the function `add_exclamation` taking `s`
fn add_exclamation(s: &mut String) {
s.push_str("!");
}
// Entry point: execution of the program starts here
fn main() {
// Declare a mutable variable `message`, initialized to `String::from("Hello")`
let mut message = String::from("Hello");
add_exclamation(&mut message);
// Print "{}" to the console, substituting in `message` (with a trailing newline)
println!("{}", message);
}Login to try C/C++/Java/PHP code in the editor
Only One Mutable Reference at a Time
Rust enforce करता है कि किसी दिए scope के अंदर किसी value के ज़्यादा से ज़्यादा एक mutable reference मौजूद हो सकता है, code के दो हिस्सों को अचानक एक साथ वही data बदलने से रोकते हुए।
r1 का scope r2 बनाए जाने से पहले खत्म होता है -- यही इसे compile कराता है।उदाहरण: Only One Mutable Reference at a Time
// Entry point: execution of the program starts here
fn main() {
// Declare a mutable variable `count`, initialized to `5`
let mut count = 5;
{
// Declare an immutable variable `r1`, set to `&mut count`
let r1 = &mut count;
*r1 += 1;
}
// Declare an immutable variable `r2`, set to `&mut count`
let r2 = &mut count;
*r2 += 1;
// Print "count = {}" to the console, substituting in `count` (with a trailing newline)
println!("count = {}", count);
}Login to try C/C++/Java/PHP code in the editor
Cannot Mix Mutable and Immutable References
आप एक ही value के किसी भी immutable references के साथ एक साथ एक mutable reference नहीं रख सकते, क्योंकि अन्यथा एक reader data को mid-read में अचानक बदलते हुए देख सकता है।
उदाहरण: Cannot Mix Mutable and Immutable References
// Entry point: execution of the program starts here
fn main() {
// Declare a mutable variable `value`, initialized to `10`
let mut value = 10;
{
// Declare an immutable variable `readable`, set to `&value`
let readable = &value;
// Print "Read before mutation: {}" to the console, substituting in `readable` (with a trailing newline)
println!("Read before mutation: {}", readable);
}
// Declare an immutable variable `writable`, set to `&mut value`
let writable = &mut value;
*writable += 5;
// Print "After mutation: {}" to the console, substituting in `value` (with a trailing newline)
println!("After mutation: {}", value);
}Login to try C/C++/Java/PHP code in the editor
Dereferencing to Modify
एक mutable reference के पीछे की value बदलने के लिए, underlying data को सीधे access करने के लिए dereference operator * उपयोग करें।
उदाहरण: Dereferencing to Modify
// Define the function `double` taking `n`
fn double(n: &mut i32) {
*n *= 2;
}
// Entry point: execution of the program starts here
fn main() {
// Declare a mutable variable `x`, initialized to `7`
let mut x = 7;
double(&mut x);
// Print "x is now {}" to the console, substituting in `x` (with a trailing newline)
println!("x is now {}", x);
}Login to try C/C++/Java/PHP code in the editor
- उसी scope में उसी value के दो mutable references बनाने की कोशिश करना, जिसे borrow checker मना करता है।
- एक ही value के लिए एक साथ एक mutable reference और एक immutable reference mix करना।
- एक mutable reference बनाते समय original variable और reference खुद दोनों पर
mutभूल जाना।
- एक mutable reference
&mut valueलिखा जाता है और borrowed data modify करने देता है। - किसी particular value का एक समय में इसके scope के अंदर सिर्फ एक mutable reference मौजूद हो सकता है।
- आपके पास एक ही समय में एक mutable reference और कोई immutable references active नहीं हो सकते।
- Mutably borrow किए जाने से पहले original variable को खुद
mutसे declare किया जाना चाहिए।
Chapter Quiz — Complete all 6 topics to unlock
0/6 topics done
Complete these topics first: