सूचक क्षय के लिए सरणी क्या है?

Question

सूचक क्षय सरणी क्या है? क्या एरे पॉइंटर्स से कोई संबंध है?

Comments

बहुत कम जाना जाता है: यूनीरी प्लस ऑपरेटर को "क्षय ऑपरेटर" के रूप में इस्तेमाल किया जा सकता है: यह देखते हुए int a[10]; int b(void);, फिर +aएक इंट्री पॉइंटर है और +bएक फ़ंक्शन पॉइंटर है। यदि आप किसी संदर्भ को स्वीकार करने वाले टेम्पलेट में इसे पास करना चाहते हैं तो उपयोगी है।

— जोहान्स शहाब -

@litb - parens एक ही करेंगे (जैसे, (a) एक एक्सप्रेशन का मूल्यांकन करने वाला एक एक्सप्रेशन होना चाहिए) - ?.

— माइकल बूर

std::decayC ++ 14 से एक + + पर सरणी को क्षय करने का एक कम अस्पष्ट तरीका होगा।

— लीजेंड्स 2

@ JohannesSchaub-litb इस सवाल का दोनों सी और सी टैग है के बाद से ++, मैं स्पष्ट करने के लिए हालांकि चाहते हैं कि +aऔर +bसी में कानूनी रहे हैं ++, यह सी (में गैर कानूनी है C11 6.5.3.3/1 "एकल के संकार्य +या -ऑपरेटर होगा अंकगणित प्रकार ")

— MM

@ काल अधिकार। लेकिन मुझे लगता है कि यह एकता + के साथ चाल के रूप में कम ज्ञात नहीं है। जिस कारण से मैंने इसका उल्लेख किया वह महज इसलिए नहीं था क्योंकि यह फैसला करता है, बल्कि इसलिए कि इसके साथ खेलने के लिए कुछ मज़ेदार चीजें हैं;)

— जोहान्स स्काउब -

Answer 1

यह कहा जाता है कि पॉइंटर्स में "क्षय" को गिरफ्तार करता है। C ++ एरे के रूप में घोषित int numbers [5]किया गया री-पॉइंट नहीं हो सकता है, अर्थात आप नहीं कह सकते numbers = 0x5a5aff23। अधिक महत्वपूर्ण बात यह है कि क्षय शब्द प्रकार और आयाम के नुकसान को दर्शाता है; आयाम जानकारी (संख्या 5) को खोने से numbersक्षय int*और प्रकार int [5]कोई और नहीं है । उन मामलों के लिए यहां देखें जहां क्षय नहीं होता है ।

यदि आप किसी सरणी को मान से पास कर रहे हैं, तो आप वास्तव में एक पॉइंटर को कॉपी कर रहे हैं - सरणी के पहले तत्व के लिए एक पॉइंटर पैरामीटर पर कॉपी किया जाता है (जिसका प्रकार भी पॉइंटर एरे तत्व का प्रकार होना चाहिए)। यह सरणी की क्षय प्रकृति के कारण काम करता है; एक बार सड़ने के बाद, sizeofअब पूर्ण सरणी का आकार नहीं देता है, क्योंकि यह अनिवार्य रूप से एक संकेतक बन जाता है। यही कारण है कि इसे संदर्भों या सूचक द्वारा पारित करने के लिए (अन्य कारणों के अलावा) पसंद किया जाता है।

एक सरणी में पास होने के तीन तरीके ¹ :

void by_value(const T* array)   // const T array[] means the same
void by_pointer(const T (*array)[U])
void by_reference(const T (&array)[U])

अंतिम दो उचित sizeofजानकारी देंगे , जबकि पहला तर्क नहीं होगा क्योंकि सरणी तर्क पैरामीटर को सौंपा गया है।

^{1 निरंतर यू को संकलन-समय पर जाना चाहिए।}

Comments

मूल्य से पहली बार कैसे गुजर रहा है?

— rlbond

by_value सरणी के पहले तत्व के लिए एक संकेतक पारित कर रहा है; समारोह मापदंडों के संदर्भ में, T a[]के समान है T *a। by_pointer एक ही चीज़ को पार कर रहा है, सिवाय इसके कि सूचक मान अब योग्य है const। यदि आप एक पॉइंटर को ऐरे में पास करना चाहते हैं (जैसा कि ऐरे के पहले एलिमेंट के लिए पॉइंटर के विपरीत), सिंटैक्स है T (*array)[U]।

— जॉन बोडे

"उस सरणी के लिए एक स्पष्ट सूचक के साथ" - यह गलत है। अगर aकी एक सरणी है char, तो aइस प्रकार का है char[N], और करने के लिए क्षय होगा char*; लेकिन &aप्रकार का है char(*)[N], और क्षय नहीं होगा ।

— पावेल मिनाएव

@FredOverflow: इसलिए यदि Uपरिवर्तन आपको दो स्थानों में बदलने के लिए याद करने की जरूरत नहीं है, या मूक कीड़े जोखिम ... स्वायत्तता!

— ऑर्बिट

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

— जुआनकोपंजा

Answer 2

एरे मूल रूप से C / C ++ में पॉइंटर्स के समान होते हैं, लेकिन काफी नहीं। एक बार जब आप एक सरणी परिवर्तित करते हैं:

const int a[] = { 2, 3, 5, 7, 11 };

एक पॉइंटर में (जो कास्टिंग के बिना काम करता है, और इसलिए कुछ मामलों में अप्रत्याशित रूप से हो सकता है):

const int* p = a;

आप sizeofसरणी में तत्वों को गिनने के लिए ऑपरेटर की क्षमता खो देते हैं :

assert( sizeof(p) != sizeof(a) );  // sizes are not equal

इस खोई हुई क्षमता को "क्षय" के रूप में जाना जाता है।

अधिक जानकारी के लिए, सरणी क्षय के बारे में इस लेख को देखें ।

Comments

एरे मूल रूप से पॉइंटर्स के समान नहीं हैं ; वे पूरी तरह से अलग जानवर हैं। अधिकांश संदर्भों में, एक सरणी को एक पॉइंटर के रूप में माना जा सकता है , और एक पॉइंटर का इलाज किया जा सकता है जैसे कि यह एक सरणी था, लेकिन यह उतना ही करीब है जितना उन्हें मिलता है।

— जॉन बोडे

@ जॉन, मेरी अभद्र भाषा को क्षमा करें। मैं एक लंबे समय तक बैकस्टोरी में फंसने के बिना जवाब पाने की कोशिश कर रहा था, और "मूल रूप से ... लेकिन काफी नहीं" उतना ही एक स्पष्टीकरण है जितना मुझे कॉलेज में मिला। मुझे यकीन है कि जिस किसी को भी दिलचस्पी है, वह आपके द्वारा की गई टिप्पणी से अधिक सटीक चित्र प्राप्त कर सकता है।

— सिस्टम PAUSE

"बिना कास्टिंग के काम करता है" का अर्थ "समान रूप से होता है" प्रकार के रूपांतरणों के बारे में बात करते समय

— एमएम

Answer 3

यहाँ मानक क्या कहते हैं (C99 6.3.2.1/3 - अन्य ऑपरेंड्स - लवल्यूज़, सरणियाँ और फ़ंक्शन डिज़ाइनर):

सिवाय इसके कि जब यह आकार ऑपरेटर या यूनिरी और ऑपरेटर का ऑपरेंड है, या एक सरणी को इनिशियलाइज़ करने के लिए उपयोग किया जाने वाला एक स्ट्रिंग शाब्दिक है, तो एक एक्सप्रेशन के साथ टाइप करने वाला एक्सप्रेशन '' टाइप ऑफ़ टाइप '' में बदल जाता है। '' टाइप करें जो एरे ऑब्जेक्ट के प्रारंभिक तत्व को इंगित करता है और एक लैवल्यू नहीं है।

इसका मतलब यह है कि किसी भी तरह से सरणी नाम का उपयोग किसी भी अभिव्यक्ति में किया जाता है, यह स्वचालित रूप से सरणी में 1 आइटम के लिए एक पॉइंटर में बदल जाता है।

ध्यान दें कि फ़ंक्शन नाम एक समान तरीके से कार्य करते हैं, लेकिन फ़ंक्शन पॉइंटर्स का उपयोग बहुत कम और बहुत अधिक विशिष्ट तरीके से किया जाता है कि यह लगभग नाम के भ्रम की स्थिति पैदा नहीं करता है क्योंकि सरणी नामों से पॉइंटर्स तक स्वचालित रूपांतरण होता है।

C ++ मानक (4.2 ऐरे-टू-पॉइंटर कन्वर्शन) रूपांतरण आवश्यकता को कम करता है (जोर मेरा):

"एनटी की सरणी" या "टी की अज्ञात सीमा की सरणी" का एक प्रकार का अंतराल या अंतराल, " टाइप्टर टू टी।" के प्रकार में परिवर्तित किया जा सकता है।

तो रूपांतरण नहीं करता है तो होना यह बहुत ज्यादा हमेशा सी में दिखाई देता है (इस कार्यों अधिभार की सुविधा देता है या टेम्पलेट्स सरणी प्रकार पर से मेल खाते हैं)।

यह भी क्यों सी में आप फ़ंक्शन प्रोटोटाइप / परिभाषाओं में सरणी मापदंडों का उपयोग करने से बचना चाहिए (मेरी राय में - अगर कोई सामान्य समझौता है तो मुझे यकीन नहीं है)। वे भ्रम का कारण हैं और वैसे भी एक कल्पना है - सूचक मापदंडों का उपयोग करें और भ्रम पूरी तरह से दूर नहीं जा सकता है, लेकिन कम से कम पैरामीटर घोषणा झूठ नहीं है।

Comments

कोड की एक उदाहरण रेखा क्या है जहां एक "अभिव्यक्ति जिसमें 'प्रकार का सरणी' है" "एक सरणी को आरंभीकृत करने के लिए उपयोग किया जाने वाला एक स्ट्रिंग शाब्दिक है"?

— गैरेट

@Garrett char x[] = "Hello";। 6 तत्वों का सरणी "Hello"क्षय नहीं करता है; इसके बजाय xआकार मिलता है 6और इसके तत्वों के तत्वों से आरंभ किया जाता है "Hello"।

— MM

Answer 4

"क्षय" एक सरणी प्रकार से सूचक प्रकार के लिए अभिव्यक्ति के निहित रूपांतरण को संदर्भित करता है। अधिकांश संदर्भों में, जब संकलक एक सरणी अभिव्यक्ति देखता है, तो यह अभिव्यक्ति के प्रकार को "एन-एलिमेंट सरणी ऑफ़ टी" से "पॉइंटर टू टी" में परिवर्तित करता है और एक्सप्रेशन के मूल्य को एरे के पहले तत्व के पते पर सेट करता है। । इस नियम के अपवाद तब होते हैं जब एक सरणी sizeofया तो &ऑपरेटर या ऑपरेटरों का एक ऑपरेंड होता है , या सरणी एक स्ट्रिंग शाब्दिक है जिसे घोषणा में इनिशियलाइज़र के रूप में उपयोग किया जा रहा है।

निम्नलिखित कोड मान लें:

char a[80];
strcpy(a, "This is a test");

अभिव्यक्ति aप्रकार "80-एलीमेंट ऑफ़ चार" और एक्सप्रेशन "दिस इज़ ए टेस्ट" टाइप ऑफ़ "16-एलीमेंट अरेंज ऑफ़ चार" है (सी में; सी ++ स्ट्रिंग लिटरल में कॉन्स्ट चार्ज के एरेज़ हैं)। हालांकि, कॉल में strcpy(), न तो अभिव्यक्ति का एक ऑपरेंड है sizeofया नहीं &, इसलिए उनके प्रकारों को संक्षेप में "पॉइंटर टू चार" में बदल दिया जाता है, और उनके मूल्यों को प्रत्येक में पहले तत्व के पते पर सेट किया जाता है। जो strcpy()प्राप्त होता है वह सरणियाँ नहीं है, लेकिन संकेत हैं, जैसा कि इसके प्रोटोटाइप में देखा गया है:

char *strcpy(char *dest, const char *src);

यह एक सरणी पॉइंटर के समान नहीं है। उदाहरण के लिए:

char a[80];
char *ptr_to_first_element = a;
char (*ptr_to_array)[80] = &a;

दोनों ptr_to_first_elementऔर ptr_to_arrayएक ही मूल्य है ; आधार का पता हालांकि, वे अलग-अलग प्रकार के होते हैं और अलग तरह से व्यवहार किए जाते हैं, जैसा कि नीचे दिखाया गया है:

a[i] == ptr_to_first_element[i] == (*ptr_to_array)[i] != *ptr_to_array[i] != ptr_to_array[i]

याद रखें कि अभिव्यक्ति a[i]की व्याख्या की जाती है *(a+i)(जो कि केवल तभी काम करता है जब सरणी प्रकार एक सूचक प्रकार में परिवर्तित हो जाता है), इसलिए दोनों a[i]और ptr_to_first_element[i]एक ही काम करते हैं। अभिव्यक्ति के (*ptr_to_array)[i]रूप में व्याख्या की है *(*a+i)। अभिव्यक्तियों *ptr_to_array[i]और ptr_to_array[i]संदर्भ के आधार पर संकलक चेतावनी या त्रुटियां हो सकती हैं; यदि आप उनसे मूल्यांकन करने की अपेक्षा कर रहे हैं तो वे निश्चित रूप से गलत काम करेंगे a[i]।

sizeof a == sizeof *ptr_to_array == 80

फिर, जब एक सरणी का एक ऑपरेंड होता है sizeof, तो यह एक पॉइंटर प्रकार में परिवर्तित नहीं होता है।

sizeof *ptr_to_first_element == sizeof (char) == 1
sizeof ptr_to_first_element == sizeof (char *) == whatever the pointer size
                                                  is on your platform

ptr_to_first_element चार करने के लिए एक सरल सूचक है।

Comments

नहीं है "This is a test" is of type "16-element array of char"एक "15-element array of char"? (लंबाई 14 + 1 for \ 0)

— chux -

Answer 5

C में Arrays का कोई मूल्य नहीं है।

जहाँ पर किसी वस्तु का मूल्य अपेक्षित होता है लेकिन वस्तु एक सरणी होती है, उसके पहले तत्व का पता इसके बजाय टाइप के साथ प्रयोग किया जाता है pointer to (type of array elements)।

एक फ़ंक्शन में, सभी पैरामीटर मान द्वारा पारित किए जाते हैं (सरणियां कोई अपवाद नहीं हैं)। जब आप किसी फ़ंक्शन में एक सरणी पास करते हैं तो यह "एक पॉइंटर में डिक" (एसआईसी) होता है; जब आप किसी चीज़ की तुलना किसी और चीज़ से करते हैं, तो फिर से यह "एक पॉइंटर में बदल जाता है" (sic); ...

void foo(int arr[]);

समारोह फू एक सरणी के मूल्य की उम्मीद है। लेकिन, सी में, सरणियों का कोई मूल्य नहीं है! तो fooबजाय सरणी के पहले तत्व का पता हो जाता है।

int arr[5];
int *ip = &(arr[1]);
if (arr == ip) { /* something; */ }

ऊपर की तुलना में, arrइसका कोई मूल्य नहीं है, इसलिए यह एक संकेतक बन जाता है। यह इंट का सूचक है। उस पॉइंटर की तुलना वेरिएबल से की जा सकती है ip।

सरणी अनुक्रमण सिंटैक्स में आपको देखने के लिए उपयोग किया जाता है, फिर से, गिरफ्तारी 'एक पॉइंटर को क्षय हो जाती है'

arr[42];
/* same as *(arr + 42); */
/* same as *(&(arr[0]) + 42); */

केवल एक बार एक पॉइंटर में कोई क्षय नहीं होता है जब यह आकार के ऑपरेटर का ऑपरेटर होता है, या & ऑपरेटर ('ऑपरेटर का पता'), या एक स्ट्रिंग सरणी के रूप में वर्ण सरणी को इनिशियलाइज़ करने के लिए उपयोग किया जाता है।

Comments

"ऐरे का कोई मूल्य नहीं है" - इसका क्या मतलब है? बेशक सरणियों का मूल्य है ... वे वस्तुएं हैं, आपके पास संकेत हो सकते हैं, और सी ++ में, उनके संदर्भ, आदि

— पावेल मिनावे

मेरा मानना ​​है, कड़ाई से, "मान" को सी में एक प्रकार के अनुसार किसी वस्तु के बिट्स की व्याख्या के रूप में परिभाषित किया गया है। मेरे पास एक कठिन समय है जो एक सरणी प्रकार के साथ एक उपयोगी अर्थ का पता लगा रहा है। इसके बजाय, आप कह सकते हैं कि आप एक पॉइंटर में कनवर्ट करते हैं, लेकिन यह एरे की सामग्री की व्याख्या नहीं कर रहा है, यह सिर्फ अपना स्थान प्राप्त करता है। आपको जो मिलता है, वह एक पॉइंटर का मूल्य है (और यह एक पता है), न कि किसी ऐरे का मान (यह "निहित वस्तुओं के मूल्यों का अनुक्रम" होगा, जैसा कि "स्ट्रिंग" की परिभाषा में इस्तेमाल किया गया है)। उस ने कहा, मुझे लगता है कि "एरे का मान" कहना उचित है, जब सूचक का अर्थ होता है।

— जोहान्स शाउब -

वैसे भी, मुझे लगता है कि थोड़ी अस्पष्टता है: एक वस्तु का मूल्य, और एक अभिव्यक्ति का मूल्य (जैसा कि, "प्रतिद्वंद्विता")। यदि बाद के तरीके की व्याख्या की जाती है, तो एक सरणी अभिव्यक्ति का निश्चित रूप से एक मूल्य होता है: यह एक परिणाम के लिए इसे एक क्षय करने के कारण होता है, और सूचक अभिव्यक्ति है। लेकिन अगर पूर्व तरीके से व्याख्या की जाती है, तो निश्चित रूप से एक सरणी वस्तु के लिए कोई उपयोगी अर्थ नहीं है।

— जोहान्स शहाब -

एक छोटे से फिक्स के साथ वाक्यांश के लिए +1; सरणियों के लिए यह केवल एक दोहे का स्थान नहीं है [स्थान, प्रकार]। क्या आपके पास सरणी के मामले में तीसरे स्थान के लिए कुछ और है? मैं किसी के बारे में सोच भी नहीं सकता।

— लीजेंड 2k

@ किंवदंतियां 2k: मुझे लगता है कि मैंने तीसरे स्थान का उपयोग सरणियों में किया था ताकि उन्हें केवल युगल होने का एक विशेष मामला न बनाया जा सके। शायद [स्थान, प्रकार, शून्य ] बेहतर होता।

— रात्रि

Answer 6

यह तब होता है जब सरणी रोटियां और इशारा किया जा रहा है ;-)

दरअसल, यह सिर्फ इतना है कि अगर आप किसी ऐरे को पास करना चाहते हैं, लेकिन इसके बजाय पॉइंटर पास किया जाता है (क्योंकि जो नरक आपके लिए पूरा एरे पास होगा), तो लोग कहते हैं कि खराब एरे पॉइंटर के लिए सड़ गए।

Comments

अच्छी तरह से कहा गया। एक अच्छा सरणी क्या होगा जो एक सूचक को क्षय नहीं करता है या एक जिसे क्षय से रोका जाता है? क्या आप C में एक उदाहरण का हवाला दे सकते हैं? धन्यवाद।

— अनहिलिग

@ यूनेहिलिग, निश्चित रूप से, एक सरणी को संरचना में पैक कर सकते हैं और संरचना को पास कर सकते हैं।

— माइकल क्रेलिन - हैकर

मुझे यकीन नहीं है कि आपको "काम" से क्या मतलब है। इसे सरणी के पिछले हिस्से तक पहुंचने की अनुमति नहीं है, हालांकि यह अपेक्षा के अनुरूप काम करता है यदि आप उम्मीद करते हैं कि वास्तव में क्या होगा। वह व्यवहार (हालांकि, फिर से, आधिकारिक रूप से अपरिभाषित) संरक्षित है।

— माइकल क्रेलिन - हैकर

क्षय कई स्थितियों में भी होता है जो कहीं भी सरणी को पारित नहीं कर रहे हैं (जैसा कि अन्य उत्तरों द्वारा वर्णित है)। उदाहरण के लिए, a + 1।

— MM

Answer 7

एरे डेकेयिंग का अर्थ है कि, जब कोई सरणी किसी फ़ंक्शन के पैरामीटर के रूप में पास की जाती है, तो यह एक पॉइंटर के लिए पहचान के रूप में व्यवहार किया जाता है।

void do_something(int *array) {
  // We don't know how big array is here, because it's decayed to a pointer.
  printf("%i\n", sizeof(array));  // always prints 4 on a 32-bit machine
}

int main (int argc, char **argv) {
    int a[10];
    int b[20];
    int *c;
    printf("%zu\n", sizeof(a)); //prints 40 on a 32-bit machine
    printf("%zu\n", sizeof(b)); //prints 80 on a 32-bit machine
    printf("%zu\n", sizeof(c)); //prints 4 on a 32-bit machine
    do_something(a);
    do_something(b);
    do_something(c);
}

उपरोक्त दो जटिलताएँ या अपवाद हैं।

सबसे पहले, जब C और C ++ में बहुआयामी सरणियों से निपटते हैं, तो केवल पहला आयाम खो जाता है। इसका कारण यह है कि सरणियों को स्मृति में आकस्मिक रूप से बाहर रखा जाता है, इसलिए संकलक को सभी पता होना चाहिए, लेकिन स्मृति के उस ब्लॉक में ऑफसेट की गणना करने में सक्षम होने के लिए पहला आयाम।

void do_something(int array[][10])
{
    // We don't know how big the first dimension is.
}

int main(int argc, char *argv[]) {
    int a[5][10];
    int b[20][10];
    do_something(a);
    do_something(b);
    return 0;
}

दूसरा, C ++ में, आप सरणियों के आकार को कम करने के लिए टेम्पलेट्स का उपयोग कर सकते हैं। Microsoft इसे सुरक्षित CRT फ़ंक्शन के C ++ संस्करणों के लिए उपयोग करता है जैसे strcpy_s , और आप किसी सरणी में तत्वों की संख्या को मज़बूती से प्राप्त करने के लिए इसी तरह की चाल का उपयोग कर सकते हैं ।

Comments

क्षय कई अन्य स्थितियों में होता है, न कि किसी फ़ंक्शन के लिए एक सरणी से गुजरना।

— MM

Answer 8

tl; dr: जब आप अपने द्वारा परिभाषित एक सरणी का उपयोग करते हैं, तो आप वास्तव में अपने पहले तत्व के लिए एक सूचक का उपयोग करेंगे।

इस प्रकार:

• जब आप लिखते हैं arr[idx]आप वास्तव में सिर्फ कह रहे हैं *(arr + idx)।
• फ़ंक्शंस कभी भी एरे को पैरामीटर के रूप में नहीं लेते हैं, केवल पॉइंटर्स, जब आप एक ऐरे पैरामीटर निर्दिष्ट करते हैं।

इस नियम के अपवाद:

• आप एक के भीतर कार्यों के लिए निश्चित लंबाई सरणियों पारित कर सकते हैं struct।
• sizeof() सरणी द्वारा लिया गया आकार देता है, सूचक का आकार नहीं।

Answer 9

मुझे लगता है कि फ़ंक्शन तर्क के रूप में एक सरणी को पास करने के चार (4) तरीके हैं, ऐसा करने के लिए मैं बहुत बोल्ड हो सकता हूं। यहाँ भी आपके पेरेज के लिए छोटा लेकिन काम करने वाला कोड है।

#include <iostream>
#include <string>
#include <vector>
#include <cassert>

using namespace std;

// test data
// notice native array init with no copy aka "="
// not possible in C
 const char* specimen[]{ __TIME__, __DATE__, __TIMESTAMP__ };

// ONE
// simple, dangerous and useless
template<typename T>
void as_pointer(const T* array) { 
    // a pointer
    assert(array != nullptr); 
} ;

// TWO
// for above const T array[] means the same
// but and also , minimum array size indication might be given too
// this also does not stop the array decay into T *
// thus size information is lost
template<typename T>
void by_value_no_size(const T array[0xFF]) { 
    // decayed to a pointer
    assert( array != nullptr ); 
}

// THREE
// size information is preserved
// but pointer is asked for
template<typename T, size_t N>
void pointer_to_array(const T (*array)[N])
{
   // dealing with native pointer 
    assert( array != nullptr ); 
}

// FOUR
// no C equivalent
// array by reference
// size is preserved
template<typename T, size_t N>
void reference_to_array(const T (&array)[N])
{
    // array is not a pointer here
    // it is (almost) a container
    // most of the std:: lib algorithms 
    // do work on array reference, for example
    // range for requires std::begin() and std::end()
    // on the type passed as range to iterate over
    for (auto && elem : array )
    {
        cout << endl << elem ;
    }
}

int main()
{
     // ONE
     as_pointer(specimen);
     // TWO
     by_value_no_size(specimen);
     // THREE
     pointer_to_array(&specimen);
     // FOUR
     reference_to_array( specimen ) ;
}

मुझे यह भी लगता है कि यह C ++ बनाम C. की श्रेष्ठता को दर्शाता है (संदर्भ में कम से कम संदर्भ में)।

बेशक, ढेर आवंटन, कोई अपवाद नहीं और कोई std :: lib के साथ बेहद सख्त परियोजनाएं हैं। सी ++ देशी सरणी हैंडलिंग मिशन महत्वपूर्ण भाषा सुविधा है, कोई कह सकता है।