మాడ్యూల్ పాఠాలు (1/2)
యాజమాన్యం యొక్క నియమాలు
యాజమాన్యం అనేది రస్ట్ యొక్క అత్యంత ప్రత్యేక లక్షణం. ఇది గార్బేజ్ కలెక్టర్ అవసరం లేకుండా మెమరీ భద్రతకు హామీ ఇవ్వడానికి భాషని అనుమతిస్తుంది లేదా హీప్ మెమరీని మాన్యువల్‌గా డీలాకేట్ చేయమని మిమ్మల్ని బలవంతం చేస్తుంది (C లేదా C++ లాగా).
యాజమాన్యం యొక్క మూడు నియమాలు
రస్ట్‌లో మెమరీ నిర్వహణ అనేది కంపైలర్ ద్వారా ఖచ్చితంగా తనిఖీ చేయబడిన మూడు సాధారణ నియమాల ద్వారా నిర్వహించబడుతుంది:
- రస్ట్‌లోని ప్రతి విలువ దాని యజమాని అని పిలువబడే వేరియబుల్‌ని కలిగి ఉంటుంది.
- ఒకసారి ఒక యజమాని మాత్రమే ఉండగలరు.
- యజమాని పరిధి దాటి పోయినప్పుడు, విలువ స్వయంచాలకంగా పడిపోతుంది.
స్టాక్ vs హీప్
యాజమాన్యాన్ని అర్థం చేసుకోవడానికి, డేటా ఎక్కడ ఉందో తెలుసుకోవడం ముఖ్యం:
- స్టాక్: కంపైల్ సమయంలో తెలిసిన స్థిర-పరిమాణ డేటాను నిల్వ చేస్తుంది (ఉదా., పూర్ణాంకాలు, బూలియన్‌లు). యాక్సెస్ చాలా వేగంగా ఉంది.
- హీప్: కంపైల్ సమయంలో తెలియని డైనమిక్-సైజ్ డేటాను నిల్వ చేస్తుంది (ఉదా.,
String). కేటాయింపు నెమ్మదిగా ఉంటుంది మరియు స్టాక్లో నిల్వ చేయబడిన పాయింటర్ అవసరం.
"తరలించు" యొక్క భావన
మేము ఒక కుప్ప-కేటాయింపబడిన వేరియబుల్‌ను మరొకదానికి కేటాయించినప్పుడు, మొదటి వేరియబుల్ చెల్లుబాటు కాకుండా విలువ యొక్క రస్ట్ మూవ్స్ (లేదా బదిలీ చేస్తుంది)
let s1 = String::from("ciao");
let s2 = s1; // Ownership of the text moves to s2. s1 is NO longer usable!
// println!("{}", s1); // COMPILATION ERROR! s1 is "borrow of moved value"
println!("{}", s2); // Valid!s2 మాత్రమే మెమరీని ఖాళీ చేస్తుంది కాబట్టి, ఈ ప్రవర్తన "డబుల్ ఫ్రీ ఎర్రర్"ను నివారిస్తుంది (పరిధి వెలుపలికి వెళ్లినప్పుడు అదే మెమరీని రెండుసార్లు ఖాళీ చేయడానికి ప్రయత్నిస్తుంది).
"క్లోన్" భావన (డీప్ కాపీ)
మేము String (స్టాక్ పాయింటర్‌లు మరియు హీప్‌లోని వాస్తవ టెక్స్ట్ డేటా రెండూ) యొక్క మొత్తం కంటెంట్‌లను స్పష్టంగా కాపీ చేయవలసి వస్తే, మేము .clone() పద్ధతిని ఉపయోగించవచ్చు. ఇది హీప్‌లోని డేటాను పూర్తిగా నకిలీ చేస్తుంది, కొత్త మెమరీ కేటాయింపు కోసం పనితీరు ఓవర్‌హెడ్ ఖర్చుతో ఒరిజినల్ మరియు కొత్త వేరియబుల్ రెండింటినీ చెల్లుబాటులో ఉంచుతుంది:
let s1 = String::from("ciao");
let s2 = s1.clone(); // Deep copy. Both variables remain valid!
println!("s1: {}, s2: {}", s1, s2);"కాపీ" యొక్క భావన
స్టాక్లో పూర్తిగా నిల్వ చేయబడిన సాధారణ రకాల కోసం (పూర్ణాంకాలు i32, బూలియన్‌లు bool, అక్షరాలు char వంటివి), అసైన్‌మెంట్ వాస్తవ ఆటోమేటిక్ నిస్సార కాపీని నిర్వహిస్తుంది, అంటే రెండు వేరియబుల్స్ అలాగే ఉంటాయి:
let x = 5;
let y = x; // Copies the value 5 onto the stack. Both variables are usable!
println!("x: {}, y: {}", x, y); // Valid!మీరే ప్రయత్నించండి
'హలో' వచనాన్ని కలిగి ఉన్న స్ట్రింగ్ s1ని ప్రకటించండి. s1ని s2కి కేటాయించండి (యాజమాన్యాన్ని తరలించడానికి). చివరగా, println ఉపయోగించి s2ని ప్రింట్ చేయండి!.
సూచనను చూపించు
యాజమాన్యాన్ని `s2`కి బదిలీ చేయడానికి `లెట్ s2 = s1;`ని ఉపయోగించండి మరియు దానిని `println!('{}', s2);`తో ప్రింట్ చేయండి.
3 ప్రయత్నాల తర్వాత పరిష్కారం లభిస్తుంది
5 విలువతో పూర్ణాంకం వేరియబుల్ xని ప్రకటించండి. xని yకి కేటాయించండి (కాపీని అమలు చేయడం). చివరగా, x మరియు y రెండింటినీ ఒకే printlnలో ప్రింట్ చేయండి! ప్రకటన.
సూచనను చూపించు
`లెట్ y = x;` ఆపై రెండు విలువలను ప్రింట్ చేయండి, ఉదా., `println!('{} {}', x, y);`.
3 ప్రయత్నాల తర్వాత పరిష్కారం లభిస్తుంది
Declare a String s1 with the value "Rust". Create a deep copy of s1 in a new variable s2 using the clone method. Finally, print both s1 and s2 separated by a space using the println! macro.
సూచనను చూపించు
Use `let s2 = s1.clone();` to deep copy the value of `s1` into `s2`, then print them with `println!("{} {}", s1, s2);`.
3 ప్రయత్నాల తర్వాత పరిష్కారం లభిస్తుంది