குறிப்புகள் மற்றும் கடன் வாங்குதல்

ரஸ்டில், செயல்பாடுகளுக்கு உரிமையை முன்னும் பின்னுமாக அனுப்புவது கடினமானது. இதைத் தீர்க்க, ரஸ்ட் குறிப்புகளைப் (&) பயன்படுத்துகிறது.

ஒரு மதிப்பின் குறிப்பை உருவாக்குவது கடன் வாங்குதல் எனப்படும்.

மாறாத குறிப்புகள்

& சின்னத்துடன் வகை அல்லது மாறியை முன்னொட்டு வைப்பதன் மூலம் குறிப்பு அறிவிக்கப்படுகிறது. முன்னிருப்பாக, குறிப்புகள் மாறாதவை: அவை மதிப்பைப் படிக்க அனுமதிக்கின்றன, ஆனால் அதை மாற்றாது.

fn main() {
    let s1 = String::from("hello");

    // We pass a reference to s1, not ownership
    let len = calculate_length(&s1);

    // s1 is still usable here!
    println!("The length of '{}' is {}.", s1, len);
}

fn calculate_length(s: &String) -> usize { // s is a reference to a String
    s.len()
} // Here, s goes out of scope, but since it doesn't own the value, nothing happens

மாறக்கூடிய குறிப்புகள்

நீங்கள் கடன் வாங்கிய மதிப்பை மாற்ற வேண்டும் என்றால், &mut உடன் மாறும் குறிப்பை பயன்படுத்த வேண்டும். அசல் மாறியானது mut உடன் மாற்றத்தக்கதாக அறிவிக்கப்பட வேண்டும்:

fn main() {
    let mut s = String::from("hello");

    // We pass a mutable reference
    change(&mut s);

    println!("{}", s); // Prints "hello, world"
}

fn change(some_string: &mut String) {
    some_string.push_str(", world");
}

கடன் வாங்குவதற்கான விதிகள்

தொகுக்கும் நேரத்தில் நினைவக சிதைவு மற்றும் தரவு பந்தயங்களைத் தடுக்க, ரஸ்ட் இரண்டு அடிப்படை விதிகளை செயல்படுத்துகிறது:

1. நீங்கள் ஒரே நேரத்தில் ஒரு மதிப்பிற்கு மாறாத குறிப்புகளை (&T) வைத்திருக்கலாம்.
2. அல்லது நீங்கள் ஒரு நேரத்தில் ஒரு மதிப்பில் சரியாக மாற்றக்கூடிய குறிப்பை (&mut T) வைத்திருக்கலாம்.

ஒரே நோக்கத்தில் ஒரே மதிப்புக்கான மாறாத மற்றும் மாறக்கூடிய குறிப்புகளை நீங்கள் முற்றிலும் கலக்க முடியாது:

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

let r1 = &s; // Valid
let r2 = &s; // Valid
// let r3 = &mut s; // COMPILATION ERROR! You cannot create &mut s if s is already borrowed as immutable

குறிப்பு நோக்கம் மற்றும் லெக்சிகல் அல்லாத வாழ்நாள் (NLL)

வரலாற்று ரீதியாக, ஒரு குறிப்பின் நோக்கம் அது உருவாக்கப்பட்ட தொகுதியின் இறுதி வரை நீடித்தது. இன்று, ரஸ்டின் கம்பைலர், **நான்-லெக்சிகல் லைஃப்டைம்ஸ் (NLL)**க்கு நன்றி செலுத்துகிறது: ஒரு குறிப்பின் நோக்கம் அது உண்மையில் பயன்படுத்தப்படும் கடைசி வரியில் முடிவடைகிறது, தொகுதியின் முடிவில் அவசியமில்லை.

இது பின்வரும் குறியீட்டை முற்றிலும் செல்லுபடியாகும்:

let mut s = String::from("hello");
let r1 = &s;
let r2 = &s;
println!("{} and {}", r1, r2); // Last use of r1 and r2. The immutable references expire here!

let r3 = &mut s; // Valid! No active immutable references exist at this point

நீங்களே முயற்சி செய்து பாருங்கள்