உரிமையின் விதிகள்

உரிமையானது ரஸ்டின் மிகவும் தனித்துவமான அம்சமாகும். குப்பை சேகரிப்பான் தேவையில்லாமல் அல்லது ஹீப் மெமரியை (C அல்லது C++ போன்றது) கைமுறையாக டீல்லோகேட் செய்யும்படி கட்டாயப்படுத்தாமல் நினைவக பாதுகாப்பிற்கு உத்தரவாதம் அளிக்க மொழியை இது அனுமதிக்கிறது.

உரிமையின் மூன்று விதிகள்

ரஸ்டில் நினைவக மேலாண்மை மூன்று எளிய விதிகளால் நிர்வகிக்கப்படுகிறது, இது கம்பைலரால் கண்டிப்பாக சரிபார்க்கப்படுகிறது:

1. ரஸ்டில் உள்ள ஒவ்வொரு மதிப்பும் அதன் உரிமையாளர் எனப்படும் மாறியைக் கொண்டுள்ளது.
2. ஒரு நேரத்தில் ஒரு உரிமையாளர் மட்டுமே இருக்க முடியும்.
3. உரிமையாளர் வரம்பிற்கு வெளியே செல்லும் போது, மதிப்பு தானாகவே கைவிடப்படும்.

ஸ்டாக் 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!

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