आकार (arr)/sizeof (arr [0]) कैसे काम करता है?

Question

जब पाश के लिए एक में एक सरणी के आकार की तलाश में मैंने देखा है लोगों को लिखने

for(int i = 0; i < sizeof(arr)/sizeof(arr[0]); i++){} 

sizeof(arr)/sizeof(arr[0]) कैसे है सरणी की लंबाई? यह तकनीकी रूप से कैसे काम करता है?

Answer 1

यदि आपके पास array है तो sizeof(array) सरणी पर मौजूद बाइट्स की संख्या देता है। चूंकि प्रत्येक तत्व अंतरिक्ष के 1 से अधिक बाइट ले सकता है, इसलिए आपको परिणाम को एक तत्व (sizeof(array[0])) के आकार से विभाजित करना होगा। यह आपको सरणी में तत्वों की संख्या देता है।

उदाहरण:

std::uint32_t array[10]; 

auto sizeOfInt = sizeof(std::uint32_t); // 4 
auto numOfBytes = sizeof(array); // 10*sizeOfInt = 40 
auto sizeOfElement = sizeof(array[0]); // sizeOfInt = 4 
auto numOfElements = sizeof(array)/sizeof(array[0]); // numOfBytes/sizeOfElement = 40/4 = 10 

LIVE EXAMPLE

ध्यान दें कि यदि आप एक समारोह के लिए एक सरणी गुजरती हैं, इसके बाद के संस्करण के बाद से सरणी एक सूचक को decays और sizeof(array) सूचक के आकार देता है काम नहीं करेगा ।

std::size_t function(std::uint32_t a[]) // same for void function(std::uint32_t a[10]) 
{ 
    return sizeof(a); // sizeof(std::uint32_t*)! 
} 

std::uint32_t array[10]; 
auto sizeOfArray = function(array); // array decays to a pointer inside function() 

LIVE EXAMPLE #2

Answer 2

यह तभी काम करता है arr एक सूचक में सड़ा हुआ किया गया है, वह यह है कि, यह एक सरणी प्रकार, नहीं एक सूचक प्रकार है।

sizeof(arr) सरणी द्वारा कब्जा कर लिया गया कुल आकार है।

sizeof(arr[0]) सरणी में पहले तत्व का आकार है। (ध्यान दें कि सी ++ में शून्य लंबाई सरणी की अनुमति नहीं है, इसलिए यह तत्व हमेशा मौजूद होता है यदि सरणी मौजूद है)।

चूंकि सभी तत्व एक ही आकार के होंगे, तत्वों की संख्या sizeof(arr)/sizeof(arr[0]) है।

Answer 3

किसी सरणी से निपटने पर (some_type name[some_size]) sizeof(name) यह है कि सरणी कितने बाइट्स पर कब्जा कर लेती है। एक तत्व के आकार से सरणी के कुल आकार को विभाजित करना (sizeof(name[0])) आपको सरणी में कितने तत्व हैं।

Answer 4

यह सी ++ मानक (5.3.3 sizeof)

1 में वर्णित के रूप में sizeof ऑपरेटर अपनी संकार्य की वस्तु प्रतिनिधित्व में बाइट की संख्या अर्जित करता है। ऑपरेंड या तो एक अभिव्यक्ति है, जो एक अनियमित ऑपरेंड (क्लॉज 5) है, या टाइप-आईडी को एक संश्लेषित किया गया है।

इस अभिव्यक्ति

sizeof(arr)/sizeof(arr[0]) 

में sizeof ऑपरेटर के साथ दो subexpressions किया जाता है।

यह उपसूचक

sizeof(arr) 

सरणी arr (मुझे लगता है कि arr एक सारणी है) के कब्जे में बाइट की संख्या अर्जित करता है।

उदाहरण के लिए आप की तरह

int arr[10]; 

तो संकलक स्मृति कि प्रकार int के 10 तत्वों धारण करने के लिए आरक्षण है एक सरणी घोषित करता है, तो। उदाहरण के लिए sizeof(int) 4 के बराबर है तो संकलक स्मृति के 10 * 4 = 40 बाइट आरक्षित करेगा।

उपसूचक

sizeof(arr[0]) 

सरणी में एक तत्व के कब्जे में बाइट्स की संख्या देता है। उदाहरण के लिए आप

sizeof(arr[1000]) 

क्योंकि अभिव्यक्ति का मूल्यांकन नहीं किया गया है। ऑपरेटर के अंदर प्रयुक्त वस्तु के बाइट्स (सरणी का एक तत्व) में आकार केवल महत्वपूर्ण है।

इस प्रकार यदि आप कुल बाइट्स कि एक सरणी

sizeof(arr) 

और पता है कि कितने बाइट्स सरणी के प्रत्येक तत्व पर है (एक सरणी के सभी तत्वों को एक ही आकार है) के लिए आरक्षित थे पता तो आप गणना कर सकते हैं सूत्र

sizeof(arr)/sizeof(arr[0]) 

का उपयोग कर सरणी में तत्वों की संख्या यहां एक साधारण संबंध है। आप प्रकार टी

T arr[N]; 

के एन तत्वों की एक सरणी है और आप स्मृति सरणी के कब्जे में है तो आप सूत्र

sizeof(arr)/N == size of an element of the array. 

का उपयोग करके अपने तत्व के आकार की गणना कर सकते के आकार पता है और उपाध्यक्ष कविता

आप स्मृति सरणी के कब्जे के आकार और उसकी तत्व के आकार आप सरणी में तत्वों की संख्या की गणना कर सकते पता है

sizeof(arr)/sizeof(a[0]) == N - number of elements in the array 

पिछले अभिव्यक्ति आप भी नीचे दिए तरीक़े पुनर्लेखन कर सकते हैं

sizeof(arr)/sizeof(T) == N - number of elements in the array 

क्योंकि सरणी के तत्वों के प्रकार टी और सरणी के प्रत्येक तत्व है वास्तव में बाइट्स कि प्रकार का ऑब्जेक्ट आवंटित करने के लिए आवश्यक हैं की संख्या पर है टी

आमतौर पर शुरुआती इस तरह की त्रुटि करते हैं। वे एक सरणी को एक समारोह के लिए तर्क के रूप में पास करते हैं। उदाहरण के लिए मान लेते हैं तो आप एक समारोह

void f(int a[]) 
{ 
    // ... 
} 

है और तुम समारोह अपने सरणी

int arr[10]; 
f(arr); 

तो समारोह सरणी के पहले तत्व के लिए सूचक का उपयोग करता है के पास है कि करते हैं।वास्तव में समारोह घोषणा है

void f(int *a) 
{ 
    // ... 
} 

तो अगर आप

void f(int *a) 
{ 
    size_t n = sizeof(a)/sizeof(a[0]); 
    // ... 
} 

तो a समारोह के भीतर एक सूचक है के रूप में समारोह के भीतर उदाहरण के लिए लिखने (यह एक सरणी नहीं है) तो आप कुछ मिल जाएगा जैसे

void f(int *a) 
{ 
    size_t n = sizeof(int *)/sizeof(int); 
    // ... 
} 

आम तौर पर एक सूचक 8 या 4 का इस्तेमाल किया पर्यावरण के आधार पर बाइट्स के बराबर के आकार। और आपको तत्वों की संख्या नहीं मिलेगी। आपको कुछ अजीब मूल्य मिलेगा।