sizeof सरणी स्पष्टीकरण

Question

मैं सी में एक अंतिम कल के लिए अध्ययन कर रहा हूँ, और sizeof ऑपरेटर से संबंधित प्रश्न है।

मान लें कि int का आकार 32 बिट्स है और एक सूचक 64 बिट्स है।

अगर वहाँ एक समारोह थे:

int 
foo (int zap[]) 
{ 
    int a = sizeof(zap); 
    return a; 
} 

क्योंकि zap एक सूचक है, foo8 वापसी होगी, के रूप में है कि कितने बाइट्स इस विशेष सूचक स्टोर करने के लिए आवश्यक हैं। हालांकि, निम्न कोड के साथ:

int zip[] = { 0, 1, 2, 3, 4, 5 }; 
int i = sizeof(zip); 

i होगा 6 * sizeof(int) = 6 * 4 = 24

क्यों है यह है कि sizeof(zip) रिटर्न तत्वों की संख्या बार प्रत्येक तत्व के आकार, जबकि sizeof(zap) एक के आकार देता है सूचक? क्या यह zap का आकार निर्दिष्ट नहीं है, और zip नहीं है? संकलक जानता कि zip है 6 तत्वों, लेकिन कितनी बड़ी zap हो सकता है के रूप में एक सुराग नहीं है।

Answer 1

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

सी में अधिकांश मामलों में जब आप किसी अभिव्यक्ति में सरणी का उपयोग करते हैं तो सरणी को अपने पहले तत्व में एक सूचक में रूपांतरित किया जाता है और यह वही होता है जब आप फ़ंक्शन को कॉल करते हैं। निम्नलिखित कोड में:

int bar[] = {1,2,3,4}; 
foo(bar); 

सरणी पहला तत्व के लिए सूचक में बदल जाती है और उस समारोह क्या प्राप्त करता है।

निषेध रूपांतरण का यह नियम हमेशा लागू नहीं होता है। जैसा कि आपने उदाहरण के लिए खोजा है sizeof ऑपरेटर सरणी पर काम करता है, और यहां तक ​​कि & (पता-ऑफ) ऑपरेटर मूल सरणी पर काम करता है (यानी sizeof(*&bar) == 4*sizeof(int))।

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

भले ही आप समारोह घोषणा में कोष्ठक के बीच एक संख्या डाल ...

void foo(int x[4]) 
{ 
    ... 
} 

कि संख्या पूरी तरह से संकलक द्वारा नजरअंदाज कर दिया है ... संकलक के लिए है कि घोषणा पूरी तरह से

के बराबर है

void foo(int *x) 
{ 
    ... 
} 

और उदाहरण के लिए भी यह बुला एक अलग आकार के साथ एक सरणी गुजर किसी भी त्रुटि पैदा नहीं होगा ...

int tooshort[] = {1,2,3}; 
foo(tooshort); /* Legal, even if probably wrong */ 

(वास्तव में एक संकलक एक चेतावनी दे सकता है, लेकिन पूरी तरह से कोड कानूनी सी है और अगर संकलक मानक इस प्रकार स्वीकार किया जाना चाहिए) यदि आपको लगता है कि जब समारोह तर्क में अजीब है सरणियों के बारे में इस नियम

तो मैं सहमत हूं, लेकिन इस तरह सी भाषा परिभाषित की गई है।

Answer 2

क्योंकि जिप एक सरणी है और संकलक संकलन समय पर इसके आकार को जानता है। यह सिर्फ सी में काफी सामान्य दो अलग बातें, कुछ के लिए एक ही अंकन का उपयोग का मामला

int 
foo (int zap[]) 

किसी भी विचार नहीं है पूरी तरह से

int 
foo (int *zap) 

संकलक के बराबर है कितना बड़ा जैप सकता है हो (इसलिए यह प्रोग्रामर को खोजने का कार्य छोड़ देता है)।

Answer 3

क्योंकि यह स्थिर 6 elemens साथ प्रारंभ किया गया है।

Answer 4

zip का आकार संकलन समय पर ज्ञात है और zap का आकार नहीं है। यही कारण है कि आप sizeof(zap) पर पॉइंटर का आकार और sizeof(zip) पर सरणी का आकार प्राप्त कर रहे हैं।

Answer 5

zip6 * sizeof(int) का मेमोरी ब्लॉक है, इसलिए इसका आकार 24 (आपके आर्किटेक्चर पर) है। zap (यह आपके समारोह घोषणा में int *zap रूप में लिखा जा सकता है) फिर भी किसी भी स्मृति पते को इंगित कर सकते और संकलक जानते हुए भी कितनी जगह इस पर शुरू (या यहां तक ​​युक्त इस) पता आबंटित की गई है का कोई रास्ता नहीं है।

Answer 6

संकेत करने के लिए कुछ स्थितियों wherearrays क्षय रहे हैं। फंक्शन कॉल उनमें से एक है।