उदाहरण 1:
यहां विभिन्न हेडर फ़ाइलें आयात की जाती हैं जो 'stddef.h', 'सीमाएं' और 'iostream' हैं। अक्सर उपयोग किए जाने वाले चर, प्रकार और पॉइंटर्स की परिभाषाएँ 'stddef.h' में पाई जा सकती हैं और 'सीमाएँ' हेडर फ़ाइल का उपयोग स्थिरांक के रूप में किया जाता है जो अभिन्न प्रकारों की सीमाओं का प्रतिनिधित्व करता है, जैसे कि विभिन्न डेटा प्रकारों के लिए न्यूनतम और अधिकतम मान , जो इस हेडर फ़ाइल के माध्यम से पहुंच योग्य हैं। फिर, 'iostream' जोड़ा जाता है क्योंकि डेटा को इनपुट/आउटपुट करने के लिए उपयोग किए जाने वाले फ़ंक्शन इसमें परिभाषित होते हैं।
इसके बाद यहां “std” नेमस्पेस जोड़ा जाता है। इसके नीचे, 'मुख्य()' विधि लागू की गई है। इसके अंदर, हम 'काउट' रखते हैं जो उस डेटा को प्रस्तुत करने में सहायता करता है जिसे हम यहां रखेंगे। 'numeric_limits::max()' टाइप किया गया है क्योंकि यह उच्चतम परिमित मान देता है जिसे संख्यात्मक प्रकार 'T' प्रदर्शित कर सकता है। यह प्रत्येक बंधे हुए प्रकार के लिए महत्वपूर्ण है लेकिन यह नकारात्मक नहीं हो सकता।
कोड 1:
#शामिल करें
#शामिल करें <सीमाएं>
#शामिल करें
का उपयोग करते हुए नाम स्थान कक्षा ;
int यहाँ मुख्य ( ) {
अदालत << 'size_t का अधिकतम आकार है' << संख्यात्मक सीमाएँ :: अधिकतम ( ) << अंतः ;
}
आउटपुट:
हम देख सकते हैं कि 'T' प्रकार का अधिकतम आकार अब प्रस्तुत किया गया है जो कि एक बहुत बड़ा मान है जैसा कि निम्नलिखित में दिखाया गया है:
उदाहरण 2:
यहां दो हेडर फ़ाइलें आयात की गई हैं जिनमें 'सीमाएं' और 'आईओस्ट्रीम' शामिल हैं। चूंकि डेटा को इनपुट और आउटपुट करने के लिए आवश्यक कार्यों को इसमें परिभाषित किया गया है, इसलिए यहां 'iostream' जोड़ा गया है। फिर, 'सीमाएं' हेडर फ़ाइल का उपयोग उन स्थिरांकों तक पहुंचने के लिए किया जाता है जो विभिन्न डेटा प्रकारों के लिए न्यूनतम और अधिकतम मान जैसे अभिन्न प्रकारों की सीमाओं का वर्णन करते हैं।
इसके बाद, 'std' नेमस्पेस को यहां पेश किया गया है और 'main()' फ़ंक्शन को कॉल किया गया है। इसके तहत, हम C++ प्रोग्रामिंग में पूर्णांक डेटा प्रकार की ऊपरी सीमा के उच्चतम मूल्य को प्रस्तुत करने के लिए 'cout' के अंदर 'INT_MAX' का उपयोग करते हैं। फिर, निम्नलिखित पंक्ति में, हम 'size_t' का उपयोग करते हैं जो उच्चतम मूल्य देता है।
कोड 2:
#शामिल करें#शामिल हैं <चढ़ाई>
का उपयोग करते हुए नाम स्थान कक्षा ;
int यहाँ मुख्य ( ) {
अदालत << 'अधिकतम पूर्णांक मान:' << INT_MAX << अंतः ;
अदालत << 'वह आकार जो size_t फ़ंक्शन धारण करता है:' << ( आकार_t ) 0 - 1 << अंतः ;
वापस करना 0 ;
}
उत्पादन :
पूर्णांक का अधिकतम आकार पहले प्रस्तुत किया जाता है जिसे हम 'INT_MAX' की सहायता से प्राप्त करते हैं। फिर, 'size_t' स्टोर का अधिकतम आकार प्रस्तुत किया जाता है जो हमें इस कोड में 'size_t' की सहायता से मिलता है।
उदाहरण 3:
यहां, दो हेडर फ़ाइलें, 'क्लाइमिट्स' और 'आईओस्ट्रीम' आयात की जाती हैं। 'आईओस्ट्रीम' को यहां शामिल किया गया है क्योंकि डेटा को इनपुट और आउटपुट करने के लिए आवश्यक कार्यों को इसमें परिभाषित किया गया है। इसके बाद, विभिन्न डेटा प्रकारों के लिए न्यूनतम और अधिकतम मूल्यों जैसे अभिन्न प्रकारों की सीमाओं का वर्णन करने वाले स्थिरांक को 'क्लाइमिट्स' हेडर फ़ाइल का उपयोग करके एक्सेस किया जाता है।
यहां, 'मुख्य()' फ़ंक्शन अब लागू किया गया है और 'एसटीडी' नेमस्पेस बाद में पेश किया गया है। इसके नीचे, हम C++ प्रोग्रामिंग में पूर्णांक डेटा प्रकार के अधिकतम मान की ऊपरी सीमा को आउटपुट करने के लिए 'cout' के अंदर 'INT_MAX' का उपयोग करते हैं। इसके नीचे, हम 'INT_MIN' का उपयोग करते हैं जो 'int' डेटा प्रकार का निम्न मान लौटाता है। फिर, हम 'size_t' का उपयोग करते हैं जो निम्नलिखित पंक्ति में संग्रहीत अधिकतम मूल्य प्राप्त करता है:
कोड 3:
#शामिल करें#शामिल हैं <चढ़ाई>
का उपयोग करते हुए नाम स्थान कक्षा ;
int यहाँ मुख्य ( ) {
अदालत << 'सबसे बड़ा पूर्णांक मान:' << INT_MAX << अंतः ;
अदालत << 'सबसे छोटा पूर्णांक:' << INT_MIN << अंतः ;
अदालत << 'वह आकार जो size_t फ़ंक्शन धारण करता है:' << ( आकार_t ) 0 - 1 << अंतः ;
वापस करना 0 ;
}
आउटपुट:
सबसे पहले, पूर्णांक का अधिकतम आकार प्रदर्शित होता है जिसे हम 'INT_MAX' की सहायता से प्राप्त करते हैं। दूसरा, पूर्णांक का न्यूनतम आकार प्रदर्शित होता है जिसे हम 'INT_MIN' की सहायता से प्राप्त करते हैं। फिर, इस कोड में 'size_t' की मदद से, 'size_t' स्टोर का अधिकतम आकार प्रस्तुत किया जाता है।
उदाहरण 4:
इस कोड में शामिल हेडर फ़ाइलें 'cstddef', 'iostream', और साथ ही 'array' हैं। इन हेडर फ़ाइलों को शामिल किया गया है ताकि हम उन फ़ंक्शंस का उपयोग कर सकें जिनकी परिभाषाएँ इन हेडर फ़ाइलों में परिभाषित हैं। 'सरणी' हेडर फ़ाइल यहां जोड़ी गई है क्योंकि हमें इस कोड में 'सरणी' और फ़ंक्शंस के साथ काम करना है। हम यहां 'my_sVar' वेरिएबल को 'const size_t' के साथ घोषित करते हैं और इसके आकार को प्रस्तुत करने के लिए इसे '1000' के मान के साथ आरंभ करते हैं।
इसके बाद, हम 'int' डेटा प्रकार की 'num[]' सरणी भी घोषित करते हैं और 'my_sVar' को इसके आकार के रूप में पास करते हैं। फिर, हम 'size_of()' फ़ंक्शन का उपयोग करते हैं जिसमें हम 'num' वेरिएबल को पैरामीटर के रूप में रखते हैं और इसे 'size_t' प्रकार के 'my_size' वेरिएबल में संग्रहीत करते हैं। फिर, हम 'काउट' का उपयोग करते हैं और यहां 'SIZE_MAX' टाइप करते हैं ताकि यह 'my_sVar' वेरिएबल का अधिकतम आकार प्रस्तुत कर सके।
इसके बाद, हम सरणी-प्रकार के तत्वों को छोटी संख्या में दिखाते हैं। हम इसे केवल 10 को 1000 के रूप में दिखाने के लिए चुनते हैं जो आउटपुट में फिट होने के लिए बहुत अधिक है। 'size_t' प्रकार का उपयोग करते हुए, हम यह दिखाने के लिए इंडेक्स 0 से शुरू करते हैं कि इंडेक्सिंग और गिनती दोनों के लिए 'size_t' का उपयोग कैसे किया जा सकता है। चूंकि संख्याएं घट जाएंगी, सरणी को अवरोही क्रम में दिखाया जाएगा क्योंकि हमने कोड में '-a' रखा है।
कोड 4:
#शामिल करें#शामिल करें
#शामिल करें <सरणी>
का उपयोग करते हुए नाम स्थान कक्षा ;
int यहाँ मुख्य ( ) {
कॉन्स्ट आकार_t my_sVar = 1000 ;
int यहाँ एक पर [ my_sVar ] ;
आकार_t मेरे आकार = का आकार ( एक पर ) ;
अदालत << 'my_sVar का अधिकतम आकार = ' << आकार_अधिकतम << अंतः ;
अदालत << 'संख्याओं की एक सरणी के साथ काम करते समय, size_t प्रकार इस प्रकार है।' ;
सरणी < आकार_t , 10 > my_arr ;
के लिए ( आकार_t ए = 0 ; ए ! = my_arr. आकार ( ) ; ++ ए )
my_arr [ ए ] = ए ;
के लिए ( आकार_t ए = my_arr. आकार ( ) - 1 ; ए < my_arr. आकार ( ) ; -- ए )
अदालत << my_arr [ ए ] << ' ' ;
वापस करना 0 ;
}
आउटपुट:
यह पहले वेरिएबल के अधिकतम आकार को प्रस्तुत करता है और फिर सरणी को अवरोही क्रम में प्रस्तुत करता है।
उदाहरण 5:
इस कोड में 'cstddef', 'iostream', और 'array' हेडर फ़ाइलें शामिल हैं। चूँकि इस कोड के लिए हमें 'सरणी' और फ़ंक्शंस के साथ काम करने की आवश्यकता होती है, इसलिए 'सरणी' हेडर फ़ाइल यहां रखी गई है। 'Var' वेरिएबल के आकार को प्रस्तुत करने के लिए, हम इसे यहां 'const size_t' मान के साथ घोषित करते हैं और इसे '1000' के साथ प्रारंभ करते हैं। 'var' वेरिएबल का अधिकतम आकार तब यहां प्रस्तुत किया गया है क्योंकि हमने 'cout' फ़ंक्शन का उपयोग किया था और इस फ़ील्ड में 'SIZE_MAX' निर्दिष्ट किया था।
इसके बाद, हम सरणी-प्रकार की वस्तुओं को कम मात्रा में प्रदर्शित करने का प्रयास करते हैं। अब तक, हमने केवल 20 प्रदर्शित करना चुना है क्योंकि 1000 आउटपुट भरेगा। हम प्रदर्शित करते हैं कि कैसे 'size_t' का उपयोग 'size_t' प्रकार का उपयोग करके अनुक्रमण और गिनती दोनों के लिए किया जा सकता है और सूचकांक 0 से शुरू किया जा सकता है। फिर सरणी को अवरोही क्रम में प्रदर्शित किया जाता है क्योंकि संख्याएं घट जाएंगी जैसा कि '-a' के स्थान से संकेत मिलता है। निम्नलिखित कोड:
कोड 5:
#शामिल करें#शामिल करें
#शामिल करें <सरणी>
का उपयोग करते हुए नाम स्थान कक्षा ;
int यहाँ मुख्य ( ) {
कॉन्स्ट आकार_t था = 1000 ;
अदालत << 'var का अधिकतम आकार = ' << आकार_अधिकतम << अंतः ;
अदालत << 'संख्याओं की एक सरणी के साथ उपयोग किया जाने वाला size_t प्रकार इस प्रकार दिया गया है' ;
सरणी < आकार_t , बीस > array_num ;
के लिए ( आकार_t मैं = 0 ; मैं ! = array_num. आकार ( ) ; ++ मैं )
array_num [ मैं ] = मैं ;
के लिए ( आकार_t मैं = array_num. आकार ( ) - 1 ; मैं < array_num. आकार ( ) ; -- मैं )
अदालत << array_num [ मैं ] << ' ' ;
वापस करना 0 ;
}
उत्पादन :
यह वेरिएबल को उसके अधिकतम आकार तक प्रस्तुत करने के बाद घटते क्रम में सरणी को प्रस्तुत करता है।
निष्कर्ष
इस लेख में C++ प्रोग्रामिंग में 'size_t' प्रकार का गहन अध्ययन किया गया है। हमने परिभाषित किया कि हम अपने C++ कोड में 'size_t' का उपयोग करते हैं क्योंकि यह अपना सबसे बड़ा मान संग्रहीत करता है। हमने यह भी समझाया कि यह एक अहस्ताक्षरित प्रकार है और यह नकारात्मक नहीं हो सकता। हमने C++ प्रोग्रामिंग के कोड प्रदर्शित किए जहां हमने 'size_t' का उपयोग किया और फिर इस लेख में उनके परिणाम प्रस्तुत किए।