पूर्णांक में

पूर्णांक के बारे में

पूर्णांक पूर्ण संख्याएँ होते हैं। इनमें कोई भिन्नात्मक या दशमलव भाग नहीं होता। मशीन में इन्हें बाइनरी बिटों के एक पैटर्न के रूप में रखा जाता है।

पूर्णांक साइन्ड भी हो सकते हैं और अनसाइन्ड भी। साइन्ड होने का मतलब है कि संख्या के बिटों में से एक बिट यह बताने के लिए आरक्षित रखा जाता है कि वह संख्या ऋणात्मक है या नहीं।

सभी पूर्णांकों की एक बिट चौड़ाई होती है, जो उस संख्या को बनाने वाले बिटों की संख्या ही है। इसका असर इस बात पर पड़ता है कि उस पूर्णांक टाइप से अधिकतम कौन-सी वैल्यू दर्शाई जा सकती है।

उदाहरण के लिए, सबसे आम पूर्णांक टाइपों में से एक u8 है: एक अनसाइन्ड, 8-बिट पूर्णांक। आप इस टाइप को एक बाइट के रूप में पहचान सकते हैं। इसकी न्यूनतम वैल्यू 0 और अधिकतम वैल्यू 255 होती है।

Rust में 12 पूर्णांक प्रिमिटिव टाइप होते हैं, जो बिट चौड़ाई और साइन्ड होने के आधार पर बाँटे गए हैं:

किसी पूर्णांक की बिट चौड़ाई हमेशा u या i के बाद लिखी संख्या से पता चलती है। usize और isize खास हैं: इनकी चौड़ाई टारगेट मशीन पर पॉइंटर की चौड़ाई के बराबर होती है। इसका मतलब है कि 64-बिट आर्किटेक्चर पर usize और isize 64 बिट चौड़े होते हैं, लेकिन 32-बिट आर्किटेक्चर पर वे 32 बिट चौड़े होते हैं।

मुझे कौन-सा इस्तेमाल करना चाहिए?

आम तौर पर, अगर आपको बस कोई संख्या दर्शानी है, तो i32 इस्तेमाल कीजिए: 32 बिट की रेंज इतनी चौड़ी होती है कि ओवरफ्लो होने की संभावना अपेक्षाकृत कम रहती है, और साइन्ड संख्याओं में अनसाइन्ड संख्याओं की तुलना में कम आश्चर्य होते हैं। i32, C के long या Java के int के बराबर है। अगर आप कोई न्यूमेरिक लिटरल इस्तेमाल करते हैं और टाइप साफ़-साफ़ नहीं लिखते, तो डिफ़ॉल्ट रूप से i32 माना जाता है।

अगर आप बाइनरी डेटा पर काम कर रहे हैं, तो बाइटों के साथ काम करना सबसे आसान रहता है: &[u8] या Vec<u8>।

Rust कलेक्शन के साइज़ और इंडेक्सिंग के लिए usize इस्तेमाल करता है। इसकी वजह यह है कि कंप्यूटर सैद्धांतिक रूप से usize::MAX बाइट मेमोरी को ही एड्रेस कर सकता है, इसलिए इससे बड़ा इन-मेमोरी कलेक्शन संभव नहीं है। इसलिए अगर आप कलेक्शन के साथ बहुत काम करते हैं, तो usize आपके काम आ सकता है।

अगर आपका डेटा 32-बिट पूर्णांक में नहीं आता, तो 64 या 128 बिट पूर्णांक पर जाने के बारे में सोचिए। अगर आपका डेटा 128-बिट पूर्णांक में भी नहीं आता, तो आप बिग इंटीजर टाइप इस्तेमाल कर सकते हैं, जैसे कि num-bigint में दिया गया है।

16 बिट पूर्णांक बहुत आम नहीं हैं, लेकिन कुछ खास माइक्रोकंट्रोलर के लिए कोड लिखते समय काम आ सकते हैं।

अगर आप जानते हैं कि आपके एप्लिकेशन में ऋणात्मक मान का कोई वैध मामला नहीं है, तो साइन्ड पूर्णांक की जगह अनसाइन्ड पूर्णांक इस्तेमाल करना बेहतर है। गिनती इसका अच्छा उदाहरण है।

पूर्णांकों के बीच कन्वर्ज़न

Rust में न्यूमेरिक कन्वर्ज़न अपने आप नहीं होते। अगर आपको पूर्णांक टाइपों के बीच कास्ट करना है, तो दो बुनियादी तरीके हैं: as कीवर्ड, और From तथा TryFrom ट्रेट।

as कीवर्ड का इस्तेमाल सीधा-सादा है: expr as Type। लेकिन as कास्ट इस्तेमाल करते समय आपको कई बारीकियाँ और सावधानियाँ ध्यान में रखनी होती हैं।

ट्रेट पर आधारित कास्ट करना थोड़ा ज़्यादा काम का है, लेकिन ज़्यादा सुरक्षित है: कन्वर्ज़न ट्रेट वहीं लागू होते हैं जहाँ वे सुरक्षित हों। उदाहरण के लिए, i32 From<u8>, From<u16>, From<i8>, और From<i16> को लागू करता है: इनमें से किसी भी टाइप से दर्शाई जा सकने वाली हर वैल्यू i32 में दर्शाई जा सकती है। इसे i32::from(expr) की तरह इस्तेमाल किया जा सकता है, या expr.into() की तरह, जहाँ expr उन टाइपों में से किसी एक के रूप में हल होता है। i32 TryFrom<u32>, TryFrom<u64>, TryFrom<u128>, TryFrom<usize>, TryFrom<i64>, TryFrom<i128>, और TryFrom<isize> भी लागू करता है। ये कन्वर्ज़न वैल्यू के आधार पर साफ़ तौर पर या तो सफल होंगे या ओवरफ्लो करेंगे। इनका इस्तेमाल करने के लिए आपको ज़रूरत के मुताबिक std::convert::TryFrom या std::convert::TryInto ट्रेट इम्पोर्ट करने होंगे, और फिर i32::try_from(expr) या expr.try_into() इस्तेमाल करना होगा, जहाँ expr किसी उपयुक्त टाइप के रूप में हल होता है।

as कास्ट की जगह ट्रेट पर आधारित कास्ट का इस्तेमाल आम तौर पर बेहतर माना जाता है, खासकर तब जब आप किसी चौड़े टाइप से सँकरे टाइप में कन्वर्ट कर रहे हों। ट्रेट पर आधारित कास्ट, as कास्ट से न के बराबर महँगा होता है: परफ़ॉर्मेंस की वजह से as इस्तेमाल करना फ़ायदेमंद नहीं है, सिवाय इसके कि वह कोड बेहद हॉट लूप में हो।