usize बनाम u32 Rust में: क्या अंतर है और क्या चुनें

usize बनाम u32: Rust में पूर्णांक प्रकारों का द्वंद्व

\n\n

यदि आप कम से कम एक सप्ताह से Rust में कोड लिख रहे हैं, तो आप निश्चित रूप से इस स्थिति का सामना कर चुके हैं: कंपाइलर त्रुटि देता है क्योंकि आप वेक्टर को इंडेक्स करने के लिए u32 का उपयोग करने का प्रयास कर रहे हैं, जबकि उसे usize की आवश्यकता है। या इसके विपरीत — आप किसी फ़ंक्शन में usize पास कर रहे हैं जो u32 की अपेक्षा करता है, और IDE में लाल लहर दिखाई देती है।

\n\n

Stack Overflow पर प्रश्न «What's the difference between usize and u32?» को हज़ारों बार देखा गया है। यह कोई संयोग नहीं है — इन प्रकारों के बीच भ्रम Rust में शुरुआती लोगों के लिए सबसे आम जालों में से एक है।

\n\n

आइए एक बार और हमेशा के लिए समझ लें कि वे कैसे भिन्न हैं, कब किसका उपयोग करना है, और गलती कैसे न करें। चलिए शुरू करते हैं!

\n\n

संक्षेप में: मुख्य अंतर

\n\n

usize एक अहस्ताक्षरित पूर्णांक है जिसका आकार सिस्टम आर्किटेक्चर पर निर्भर करता है। 64-बिट सिस्टम पर यह 8 बाइट्स होता है, 32-बिट पर — 4 बाइट्स। u32 हमेशा 4 बाइट्स होता है, प्लेटफ़ॉर्म की परवाह किए बिना।

\n\n

लेकिन अंतर केवल आकार का नहीं है। मुख्य बात है सिमैंटिक्स:

\n\n

\n
• usize — कलेक्शन में आकार, इंडेक्स और तत्वों की संख्या के लिए
\n
• u32 — संख्यात्मक डेटा के लिए जो 4 बिलियन से अधिक न हो
\n

\n\n

और हाँ, कंपाइलर स्पष्ट रूपांतरण के बिना उन्हें मिश्रित करने की अनुमति नहीं देता है। यह कोई बग नहीं, बल्कि एक फीचर है — इस तरह Rust आपको आर्किटेक्चर की बिट-क्षमता से संबंधित त्रुटियों से बचाता है।

\n\n

usize क्यों मौजूद है?

\n\n

कल्पना करें कि आप ऐसा कोड लिख रहे हैं जो पुराने 32-बिट माइक्रोकंट्रोलर और आधुनिक 64-बिट सर्वर दोनों पर काम करना चाहिए। 32-बिट सिस्टम पर वेक्टर की लंबाई 2^32 - 1 तत्वों से अधिक नहीं हो सकती, जबकि 64-बिट पर — 2^64 - 1 तक।

\n\n

यदि आप 64-बिट सिस्टम पर इंडेक्सिंग के लिए u32 का उपयोग करते, तो आप 4 बिलियन से अधिक तत्वों तक पहुँच ही नहीं पाते — भले ही पर्याप्त मेमोरी हो। usize इस समस्या को हल करता है: यह हमेशा वर्तमान आर्किटेक्चर पर अधिकतम संभव मेमोरी आकार को समायोजित करता है।

\n\n

// उदाहरण: usize स्वचालित रूप से आर्किटेक्चर के अनुसार समायोजित होता है\nfn main() {\n    let large_vec: Vec<u8> = vec![0; 1_000_000_000]; // 1 बिलियन तत्व\n    \n    // usize किसी भी प्लेटफ़ॉर्म पर इस इंडेक्स को समायोजित करता है\n    let index: usize = 999_999_999;\n    println!("तत्व: {}", large_vec[index]);\n    \n    // जबकि u32 32-बिट सिस्टम पर पर्याप्त नहीं हो सकता\n    // let bad_index: u32 = 999_999_999; // 32-बिट सिस्टम पर यह कंपाइल होगा, लेकिन...\n    // large_vec[bad_index as usize]; // ...रूपांतरण करना होगा\n}

\n\n

तालिका में तुलना

\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n

विशेषता	usize	u32
64-bit पर आकार	8 बाइट्स	4 बाइट्स
32-bit पर आकार	4 बाइट्स	4 बाइट्स
सीमा (64-bit)	0 .. 2^64-1	0 .. 2^32-1
मुख्य उपयोग	इंडेक्स, आकार, लंबाई	संख्यात्मक डेटा
अंतर्निहित रूपांतरण	नहीं	नहीं

\n\n

usize का उपयोग कब करें?

\n\n

हमेशा कलेक्शन की इंडेक्सिंग के लिए। यह नियम लगभग अपवाद रहित है। यदि आप vec[i] लिखते हैं, जहाँ i एक u32 है, तो कंपाइलर कहेगा: «अरे दोस्त, चलो usize का उपयोग करें»।

\n\n

// सही: इंडेक्स के लिए usize का उपयोग करें\nfn get_element(vec: &[i32], index: usize) -> Option<&i32> {\n    vec.get(index)\n}\n\n// गलत: इंडेक्सिंग के लिए u32 — रूपांतरण करना होगा\nfn get_ele