ஸ்மார்ட் பாயிண்டர்கள்: பெட்டி மற்றும் Rc

ஸ்மார்ட் பாயிண்டர் என்பது ஒரு சுட்டியைப் போல் செயல்படும் தரவுக் கட்டமைப்பாகும், ஆனால் மெட்டாடேட்டா மற்றும் கூடுதல் திறன்களைக் கொண்டுள்ளது (குறிப்பு எண்ணுதல் அல்லது தானியங்கி நினைவக மேலாண்மை போன்றவை).

ரஸ்டில், சாதாரண குறிப்புகள் (& போன்றவை) தரவை மட்டுமே கடன் வாங்கும். ஸ்மார்ட் சுட்டிகள், மறுபுறம், அவர்கள் சுட்டிக்காட்டும் தரவை பெரும்பாலும் சொந்தமாக வைத்திருக்கிறார்கள். பொதுவான எடுத்துக்காட்டுகளில் String மற்றும் Vec<T> ஆகியவை அடங்கும், ஆனால் நிலையான நூலகம் பிற சிறப்பு வாய்ந்தவற்றை வழங்குகிறது.

குவியல் ஒதுக்கீட்டுக்கான பெட்டி<T>

எளிமையான ஸ்மார்ட் பாயிண்டர் Box<T> ஆகும், இது அடுக்கை விட குவியல் இல் தரவைச் சேமிக்கிறது. குவியலாக ஒதுக்கப்பட்ட தரவுக்கான சுட்டி மட்டுமே அடுக்கில் இருக்கும்.

இது முக்கியமாக பின்வரும் சந்தர்ப்பங்களில் பயன்படுத்தப்படுகிறது:

1. தொகுக்கும் நேரத்தில் (சுழற்சி வகை போன்ற) அளவை அறிய முடியாத வகை உங்களிடம் இருந்தால், சரியான அளவு தேவைப்படும் சூழலில் அந்த வகையின் மதிப்பைப் பயன்படுத்த விரும்புகிறீர்கள்.
2. பெரிய அளவிலான தரவின் உரிமையை நகலெடுக்காமல் மாற்ற விரும்பினால்.

அடிப்படை உதாரணம்:

fn main() {
    let b = Box::new(5); // allocates the value 5 on the heap
    println!("b = {}", *b); // dereferences with * to read the value
}

சுழல்நிலை வகைகள் மற்றும் தீமைகள் பட்டியல்கள்

சுழல்நிலை வகை என்பது அதன் வரையறையின் ஒரு பகுதியாக அதன் மதிப்பைக் கொண்டிருக்கும் வகையாகும். தொகுக்கும் நேரத்தில் ரஸ்ட் ஒரு வகையின் சரியான அளவை அறிந்திருக்க வேண்டும். ஒரு சுழல்நிலை வகையின் ஆழம் எல்லையற்றதாக இருக்கக்கூடும் என்பதால், நீங்கள் ஒரு பெட்டியைப் பயன்படுத்தாத வரை கம்பைலர் பிழையை உருவாக்கும் (இது ஒரு நிலையான அளவைக் கொண்டுள்ளது, ஏனெனில் இது ஒரு சுட்டிக்காட்டி):

enum List {
    Cons(i32, Box<List>),
    Nil,
}

Rc<T>: குறிப்பு எண்ணுதல்

ஒரு மதிப்பு பல உரிமையாளர்களைக் கொண்டிருக்கும் சந்தர்ப்பங்கள் உள்ளன. Rc<T> (குறிப்பு எண்ணப்பட்டது) ஸ்மார்ட் பாயிண்டர், மதிப்பு இன்னும் பயன்பாட்டில் உள்ளதா என்பதைத் தீர்மானிக்க, மதிப்புக்கான குறிப்புகளின் எண்ணிக்கையைக் கண்காணிக்கும். எண்ணிக்கை பூஜ்ஜியத்திற்குக் குறைந்தால், ஆதாரம் பாதுகாப்பாக ஒதுக்கப்படும்.

[!குறிப்பு] Rc<T> ஒற்றை-திரிக்கப்பட்ட காட்சிகளுக்கு மட்டுமே பொருத்தமானது. மல்டி-த்ரெட் (ஒரே நேரத்தில்) காட்சிகளுக்கு, நீங்கள் Arc<T> (அணு குறிப்பு கணக்கிடப்பட்டது) பயன்படுத்த வேண்டும்.

use std::rc::Rc;

fn main() {
    let a = Rc::new(5);
    let b = Rc::clone(&a); // increments the reference count to 2
    println!("References: {}", Rc::strong_count(&a));
}

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

பயிற்சி 1: பெட்டியுடன் குவியல் ஒதுக்கீடு

பயிற்சி 2: சுழல்நிலை தரவு அமைப்பு (தீமைகள் பட்டியல்)

பயிற்சி 3: Rc உடன் உரிமையைப் பகிர்தல்