సూచనలు మరియు రుణాలు

రస్ట్‌లో, ఫంక్షన్‌లకు యాజమాన్యం ముందుకు వెనుకకు వెళ్లడం దుర్భరంగా ఉంటుంది. దీనిని పరిష్కరించడానికి, రస్ట్ సూచనలు (&)ని ఉపయోగిస్తుంది.

విలువకు సూచనను సృష్టించడాన్ని అరువుగా తీసుకోవడం అంటారు.

మార్పులేని సూచనలు

& గుర్తుతో రకం లేదా వేరియబుల్‌ను ప్రిఫిక్స్ చేయడం ద్వారా సూచన ప్రకటించబడుతుంది. డిఫాల్ట్‌గా, సూచనలు మార్పులేనివి: అవి విలువను చదవడానికి అనుమతిస్తాయి కానీ దానిని సవరించవు.

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

మీరే ప్రయత్నించండి