स्टेटिक ऐरे को वापस करने के लिए पॉइंटर्स का उपयोग करें
जब हम एक सामान्य सरणी का उपयोग करते हैं, तो कुछ प्रकार के असामान्य परिणाम होने की संभावना होती है। इससे बचने के लिए हम अपने C++ कोड में एक स्टैटिक ऐरे का इस्तेमाल करते हैं। आइए हम उस उदाहरण को समझते हैं जिसका हमने उपयोग किया है। इस फ़ंक्शन में, हमने 5 मानों के साथ एक सरणी घोषित की है, जैसा कि यहां बताया गया है।
इंट * फंक्शन ()
चूंकि मान एक पूर्णांक प्रकार होगा, इसलिए इसे नीचे उदाहरण में int के रूप में टैग किया गया है। जैसा कि हमने फ़ंक्शन को पॉइंटर के रूप में पेश किया है, फ़ंक्शन एक पॉइंटर प्रकार होगा। मान दर्ज करने के बाद, एक सरणी मुख्य कार्यक्रम में वापस आ जाती है।
मुख्य कार्यक्रम में, हमने एक फ़ंक्शन कॉल किया है। फ़ंक्शन से लौटाए गए मान को स्वीकार करने के लिए, हम एक पूर्णांक चर का उपयोग करेंगे। जब सरणी वापस आती है, तो हम इसके मूल्यों को आसानी से एक्सेस कर सकते हैं। मान मैन्युअल रूप से मुद्रित किए जाएंगे।
NS*सूचक=समारोह();पॉइंटर का उद्देश्य उस आइटम का पता लगाना है जो किसी एक सरणी के इंडेक्स पर मौजूद है। दूसरे शब्दों में, यह सरणी में मान का पता दिखाता है। फिर, हम एक फ़ंक्शन प्रोटोटाइप का उपयोग करते हैं जो पॉइंटर लौटाएगा।
फ़ंक्शन के माध्यम से लौटाए गए सरणी के आउटपुट को देखने के लिए, हमें लिनक्स के मामले में उबंटू टर्मिनल तक पहुंच की आवश्यकता है। यह लिनक्स टर्मिनल के माध्यम से आउटपुट के सुलभ होने के कारण है। लिनक्स में, हमें किसी भी टेक्स्ट एडिटर में लिखे गए C++ कोड को चलाने के लिए एक कंपाइलर की आवश्यकता होती है। यह संकलन G++ के माध्यम से किया जाता है। -o का प्रयोग किसी फाइल में आउटपुट को स्टोर करने के लिए किया जाता है। यहां, हमें आउटपुट फाइल और सोर्स कोड फाइल की जरूरत है। संकलन के बाद, हम कोड निष्पादित करेंगे:
$जी++ -याfile1 file1.c$./फ़ाइल1
आउटपुट से, हम सरणी देख सकते हैं, जिसे फ़ंक्शन में प्रारंभ किया गया था, मुख्य फ़ंक्शन में एक स्थिर सरणी का उपयोग करके प्रदर्शित किया जाता है, मैन्युअल रूप से और पॉइंटर्स के माध्यम से प्रारंभ किया जाता है।
पॉइंटर्स का उपयोग करके गतिशील रूप से आवंटित सरणी लौटाएं
गतिशील आवंटन का उपयोग करके सरणियों को वापस किया जा सकता है। नए शब्द का उपयोग करके सरणियों को गतिशील रूप से आवंटित किया जा सकता है। वे तब तक वहीं रहेंगे जब तक हम उन्हें स्वयं हटा नहीं देते। स्थिर सरणियाँ आकार में तय होती हैं, जिसका अर्थ है कि आपको आरंभीकरण के दौरान आकार प्रदान करना होगा। एक बार सरणी बन जाने के बाद, रन टाइम पर या उसके बाद आकार बढ़ाना कठिन होता है। लेकिन गतिशील सरणी के मामले में, हम जब चाहें और अधिक आइटम जोड़ सकते हैं क्योंकि जैसे ही हम इसमें मान दर्ज करते हैं, यह फैलता है। इसलिए हमें किसी आकार को निर्दिष्ट करने या पहचानने की आवश्यकता नहीं है।
उदाहरण की ओर बढ़ते हुए हमने यहां प्रयोग किया है। हमने पिछले उदाहरणों की तरह पॉइंटर्स के साथ डायनेमिक ऐरे का इस्तेमाल किया है, जहां हमने स्टैटिक ऐरे के साथ पॉइंटर्स का इस्तेमाल किया है।
NS*समारोह()फ़ंक्शन घोषणा के बाद, सरणियों को गतिशील रूप से घोषित किया जाता है:
NS*सरणी= नया NS [100];शब्द, नया, एक गतिशील सरणी बनाने के लिए लगातार प्रयोग किया जाता है। हम इसमें मान दर्ज करके सरणी पर संचालन करेंगे। उसके बाद, सरणी मुख्य कार्यक्रम में वापस आ जाती है:
अब, मुख्य कार्य पर विचार करें। हमने फ़ंक्शन कॉल किया है। जैसे ही सरणी वापस आती है, हम मान को स्वीकार करने के लिए एक सूचक पूर्णांक प्रकार चर जोड़ते हैं।
NS*सूचक=समारोह();सरणी में संग्रहीत मान मैन्युअल रूप से मुद्रित होते हैं। आउटपुट संकलन और निष्पादन विधि के माध्यम से प्राप्त किया जाता है।
संरचनाओं का उपयोग करके वापसी ऐरे
संरचनाएं सरणियों की तरह कंटेनर हैं। लेकिन सरणी में एक ही समय में एक ही डेटा प्रकार का मान होता है। और संरचनाओं के मामले में, उनमें एक से अधिक डेटा प्रकार मान होते हैं। हमने नमूना नाम की एक संरचना ली है। यहां, सरणी घोषणा कार्यों के बजाय संरचनाओं के अंदर है। वापसी प्रकार संरचना का नाम है। संरचना चर मुख्य कार्यक्रम में वापस आ गया है। संरचना घोषणा के लिए संरचना शब्द का उपयोग करती है।
संरचना नमूना{
इंट अरे[100];
};
संरचना की घोषणा के बाद, हमने एक फ़ंक्शन का उपयोग किया है जिसमें संरचना की एक वस्तु बनाई जाती है। इस ऑब्जेक्ट का उपयोग संरचना तक पहुंचने के लिए किया जाएगा। यह फ़ंक्शन संरचना के ऑब्जेक्ट को मुख्य फ़ंक्शन पर वापस कर देगा ताकि हम इस ऑब्जेक्ट के माध्यम से सरणी को प्रिंट कर सकें। एक वेरिएबल को वेरिएबल में मान मिलेंगे। यह मान वह पूर्णांक संख्या है जिस तक हम सरणी में मान दर्ज करेंगे। जैसा कि इस उदाहरण में, हमने संख्या के रूप में 6 का चयन किया है। तो, संख्याएं सरणी में 6 तक दर्ज की जाएंगी।
संरचना नमूना func(NSएन) 
अब, मुख्य कार्यक्रम की ओर बढ़ते हुए, हमने इसके माध्यम से सरणी तक पहुँचने के लिए एक वस्तु बनाई है:
संरचना नमूना x; 
ऑब्जेक्ट इनिशियलाइज़ेशन के बाद, वेरिएबल में एक मान जोड़ा जाता है, जिस तक हम चाहते हैं कि नंबर एरे में दर्ज हों। फ़ंक्शन कॉल में, हम पैरामीटर में मान पास करेंगे:
एक्स=समारोह(एन);हमारे पास फॉर लूप का उपयोग करके डिस्प्ले होगा। मान मुख्य कार्यक्रम की शुरुआत में घोषित वस्तु के माध्यम से प्रदर्शित होते हैं:
आउटपुट इंगित करता है कि परिणाम में 6 मान दिखाए गए हैं क्योंकि हमने प्रोग्राम में 6 नंबर दर्ज किए हैं।
Std . का उपयोग करके वापसी ऐरे
सी ++ फ़ंक्शन से सरणी वापस करने के लिए कई विधियों का उपयोग करता है। उनमें से एक std :: array के माध्यम से है। यह संरचना का एक टेम्पलेट है। यह सुविधा दो और फ़ंक्शन भी प्रदान करती है जो आकार () और खाली () हैं। एक सरणी नाम लौटाया जाता है जो इंगित करता है कि संपूर्ण सरणी मुख्य कार्यक्रम में वापस आ गई है। यहां, हम एक हेडर फाइल ऐरे जोड़ेंगे। पुस्तकालय के अलावा, इसमें सरणी के सभी कार्य शामिल हैं।
#शामिल 
चूंकि हम पूरे सरणी को उसके नाम से वापस कर सकते हैं, इसलिए किसी फ़ंक्शन की घोषणा में, हम सरणी का उपयोग रिटर्न प्रकार के रूप में करेंगे। डेटा सरणी में दर्ज किया गया है। उसके बाद, सरणी मुख्य कार्यक्रम में वापस आ जाएगी। मुख्य फ़ंक्शन की ओर बढ़ते हुए, एक सरणी चर फ़ंक्शन को कॉल करने पर सरणी को स्वीकार करेगा।
आगमन=समारोह();फिर से, लूप के लिए सरणी मान प्रदर्शित करने के लिए उपयोग किया जाएगा। हम नीचे प्रदर्शित छवि से आउटपुट देखते हैं। जैसा कि हमने 10 आकारों का उपयोग किया है, 0 नंबर दर्ज किए जाएंगे। इसलिए, ये प्रदर्शित होते हैं:
वेक्टर कंटेनर के माध्यम से वापसी सरणी
यह दृष्टिकोण एक गतिशील रूप से आवंटित सरणी है। जैसा कि इस मामले में, सरणी आकार निर्दिष्ट करने की कोई आवश्यकता नहीं है। हमें यहां किसी आकार के पैरामीटर की आवश्यकता नहीं है। इस उदाहरण का उपयोग करते हुए, हमें पुस्तकालय में एक वेक्टर हेडर जोड़ने की जरूरत है जिसमें वेक्टर की कार्यक्षमता शामिल है।
फ़ंक्शन की ओर बढ़ते हुए, जहां रिटर्न प्रकार भी एक इंट वेक्टर है और पैरामीटर में एक तर्क के रूप में एक वेक्टर पॉइंटर भी होता है। अस्थायी नाम के साथ एक सरणी यहाँ पेश की गई है:
वेक्टर<NS>MultiplyArrayByTwo(स्थिरांकवेक्टर<NS> *आगमन)फ़ंक्शन tmp.push_back () फ़ंक्शन का उपयोग करके सरणी के तत्वों को दो से गुणा करेगा। फिर, टीएमपी वापस करें। एक ऑटो-टाइप वेरिएबल फ़ंक्शन से सरणी के मानों को स्वीकार करेगा। सरणी में आइटम शामिल हैं।
आउटपुट वेक्टर कंटेनर के काम को दिखाता है।
निष्कर्ष
उपरोक्त लेख में, हमने फ़ंक्शन से एक सरणी वापस करने की कार्यक्षमता की व्याख्या करने के लिए पांच सबसे अधिक उपयोग की जाने वाली विधियों का वर्णन किया है।