मैं sizeofकिसी भी सरणी के दो अलग-अलग आकार, या तत्वों की संख्या या बाइट्स में से किसी एक को प्राप्त करने के लिए (भले ही इसका उपयोग किया जा सकता है) का उपयोग न करने की सलाह दूंगा, जो कि पिछले दो मामले हैं जो मैं यहां दिखाता हूं। प्रत्येक दो आकारों के लिए, नीचे दिखाए गए मैक्रो का उपयोग इसे सुरक्षित बनाने के लिए किया जा सकता है। कारण देखरेख करने के लिए कोड का स्पष्ट इरादा है, और फर्क है sizeof(ptr)से sizeof(arr)पहली नजर में तो यह है कि कीड़े तो हर कोई कोड को पढ़ने के लिए स्पष्ट हैं (जो इस तरह से लिखा स्पष्ट नहीं है),।
टी एल; डॉ:
#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]) + must_be_array(arr))
#define ARRAY_SSIZE(arr) ((ptrdiff_t)ARRAY_SIZE(arr))
#define ARRAY_BYTES(arr) (sizeof((arr)[0]) * ARRAY_SIZE(arr))
must_be_array(arr)(नीचे परिभाषित किया गया है) आईएस की जरूरत -Wsizeof-pointer-divहै जो छोटी गाड़ी (अप्रैल / 2020 तक) है:
#define is_same_type(a, b) __builtin_types_compatible_p(typeof(a), typeof(b))
#define is_array(a) (!is_same_type((a), &(a)[0]))
#define Static_assert_array(a) _Static_assert(is_array(a), "Not a `[]` !")
#define must_be_array(a) ( \
0 * (int)sizeof( \
struct { \
Static_assert_array(a); \
char ISO_C_forbids_a_struct_with_no_members__; \
} \
) \
)
इस विषय के बारे में महत्वपूर्ण कीड़े हैं: https://lkml.org/lkml/2015/9/3/428
मैं उस समाधान से असहमत हूं जो लिनुस प्रदान करता है, जो कि कार्यों के मापदंडों के लिए सरणी संकेतन का उपयोग कभी नहीं करना है।
मुझे प्रलेखन के रूप में सरणी संकेतन पसंद है कि एक सूचक एक सरणी के रूप में उपयोग किया जा रहा है। लेकिन इसका मतलब यह है कि एक मूर्ख-प्रूफ समाधान को लागू करने की आवश्यकता है ताकि छोटी गाड़ी कोड लिखना असंभव हो।
एक सरणी से हमारे तीन आकार होते हैं जिन्हें हम जानना चाहते हैं:
- सरणी के तत्वों का आकार
- सरणी में तत्वों की संख्या
- स्मृति में सरणी का उपयोग करने वाले बाइट्स में आकार
सरणी के तत्वों का आकार
पहला एक बहुत ही सरल है, और इससे कोई फर्क नहीं पड़ता कि हम किसी सरणी या पॉइंटर के साथ काम कर रहे हैं, क्योंकि यह उसी तरह से किया गया है।
उपयोग का उदाहरण:
void foo(ptrdiff_t nmemb, int arr[static nmemb])
{
qsort(arr, nmemb, sizeof(arr[0]), cmp);
}
qsort() इसके तीसरे तर्क के रूप में इस मूल्य की आवश्यकता है।
अन्य दो आकारों के लिए, जो प्रश्न का विषय हैं, हम यह सुनिश्चित करना चाहते हैं कि हम एक सरणी के साथ काम कर रहे हैं, और संकलन को तोड़ दें यदि नहीं, क्योंकि यदि हम एक सूचक के साथ काम कर रहे हैं, तो हमें गलत मान मिलेंगे । जब संकलन टूट जाता है, तो हम आसानी से देख पाएंगे कि हम किसी एरे से काम नहीं कर रहे हैं, बल्कि एक पॉइंटर के साथ, और हमें कोड को एक वैरिएबल या मैक्रो के साथ लिखना होगा, जो साइज़ को स्टोर करता है सूचक के पीछे सरणी।
सरणी में तत्वों की संख्या
यह सबसे आम है, और कई जवाबों ने आपको विशिष्ट मैक्रो ARRAY_SIZE प्रदान किया है:
#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
यह देखते हुए कि ARRAY_SIZE के परिणाम का आमतौर पर हस्ताक्षरित चर प्रकार के साथ उपयोग किया जाता है ptrdiff_t, इस मैक्रो के एक हस्ताक्षरित संस्करण को परिभाषित करना अच्छा है:
#define ARRAY_SSIZE(arr) ((ptrdiff_t)ARRAY_SIZE(arr))
PTRDIFF_MAXमैक्रो के इस हस्ताक्षर किए गए संस्करण के लिए सदस्यों से अधिक के साथ अमान्य मूल्य देने जा रहे हैं, लेकिन C17 :: 6.5.6.9 को पढ़ने से, जैसे कि पहले से ही आग से खेल रहे हैं। केवल ARRAY_SIZEऔर size_tउन मामलों में उपयोग किया जाना चाहिए।
संकलक के हाल के संस्करण, जैसे कि जीसीसी 8, जब आप इस मैक्रो को एक पॉइंटर पर लागू करते हैं, तो यह आपको चेतावनी देगा, इसलिए यह सुरक्षित है (पुराने संकलक के साथ इसे सुरक्षित बनाने के अन्य तरीके हैं)।
यह प्रत्येक तत्व के आकार से पूरे सरणी के बाइट्स में आकार को विभाजित करके काम करता है।
उपयोग के उदाहरण:
void foo(ptrdiff_t nmemb)
{
char buf[nmemb];
fgets(buf, ARRAY_SIZE(buf), stdin);
}
void bar(ptrdiff_t nmemb)
{
int arr[nmemb];
for (ptrdiff_t i = 0; i < ARRAY_SSIZE(arr); i++)
arr[i] = i;
}
यदि ये फ़ंक्शन सरणियों का उपयोग नहीं करते हैं, लेकिन उन्हें मापदंडों के रूप में मिला है, तो पूर्व कोड संकलित नहीं करेगा, इसलिए बग होना असंभव होगा (यह देखते हुए कि हाल ही में संकलक संस्करण का उपयोग किया गया है, या कि कुछ अन्य चाल का उपयोग किया जाता है) , और हमें मूल्य द्वारा मैक्रो कॉल को बदलने की आवश्यकता है:
void foo(ptrdiff_t nmemb, char buf[nmemb])
{
fgets(buf, nmemb, stdin);
}
void bar(ptrdiff_t nmemb, int arr[nmemb])
{
for (ptrdiff_t i = 0; i < nmemb; i++)
arr[i] = i;
}
स्मृति में सरणी का उपयोग करने वाले बाइट्स में आकार
ARRAY_SIZE आमतौर पर पिछले मामले के समाधान के रूप में उपयोग किया जाता है, लेकिन यह मामला शायद ही कभी सुरक्षित रूप से लिखा जाता है, शायद इसलिए कि यह कम आम है।
इस मान को प्राप्त करने का सामान्य तरीका उपयोग करना है sizeof(arr)। समस्या: पिछले वाले के समान ही; यदि आपके पास एक सरणी के बजाय एक सूचक है, तो आपका कार्यक्रम पागल हो जाएगा।
समस्या के समाधान में पहले की तरह ही मैक्रो का उपयोग करना शामिल है, जिसे हम सुरक्षित होना जानते हैं (यह संकलक पर लागू होता है तो यह संकलक को तोड़ता है):
#define ARRAY_BYTES(arr) (sizeof((arr)[0]) * ARRAY_SIZE(arr))
यह कैसे काम करता है बहुत सरल है: यह उस विभाजन को पूर्ववत ARRAY_SIZEकरता है, जो गणितीय रद्दीकरण के बाद आप केवल एक के साथ समाप्त होता है sizeof(arr), लेकिन ARRAY_SIZEनिर्माण की अतिरिक्त सुरक्षा के साथ ।
उपयोग का उदाहरण:
void foo(ptrdiff_t nmemb)
{
int arr[nmemb];
memset(arr, 0, ARRAY_BYTES(arr));
}
memset() इसके तीसरे तर्क के रूप में इस मूल्य की आवश्यकता है।
पहले की तरह, यदि सरणी को एक पैरामीटर (एक सूचक) के रूप में प्राप्त किया जाता है, तो यह संकलन नहीं करेगा, और हमें मूल्य द्वारा मैक्रो कॉल को बदलना होगा:
void foo(ptrdiff_t nmemb, int arr[nmemb])
{
memset(arr, 0, sizeof(arr[0]) * nmemb);
}
आज मुझे पता चला कि जीसीसी में नई चेतावनी केवल तभी काम करती है जब मैक्रो को एक हेडर में परिभाषित किया गया है जो सिस्टम हेडर नहीं है। यदि आप अपने सिस्टम (आमतौर पर /usr/local/include/या /usr/include/) ( #include <foo.h>) में स्थापित हैडर में मैक्रो को परिभाषित करते हैं , तो संकलक एक चेतावनी का उत्सर्जन नहीं करेगा (मैंने जीसीसी 9.3.0 की कोशिश की)।
इसलिए हम #define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))इसे सुरक्षित बनाना चाहते हैं। हमें C11 _Static_assert()और कुछ GCC एक्सटेंशन की आवश्यकता होगी : अभिव्यक्ति और कथन में अभिव्यक्तियाँ , __builtin_types_compatible_p :
#define is_same_type(a, b) __builtin_types_compatible_p(typeof(a), typeof(b))
#define is_array(a) (!is_same_type((a), &(a)[0]))
#define Static_assert_array(a) _Static_assert(is_array(a), "Not a `[]` !")
#define ARRAY_SIZE(arr) ( \
{ \
Static_assert_array(arr); \
sizeof(arr) / sizeof((arr)[0]); \
} \
)
अब ARRAY_SIZE()पूरी तरह से सुरक्षित है, और इसलिए इसके सभी डेरिवेटिव सुरक्षित होंगे।
अद्यतन: libbsd प्रदान करता है __arraycount() :
Libbsd में मैक्रो प्रदान करता __arraycount()है<sys/cdefs.h> , जो असुरक्षित है क्योंकि इसमें कोष्ठक की एक जोड़ी का अभाव है, लेकिन हम उन कोष्ठक को स्वयं जोड़ सकते हैं, और इसलिए हमें अपने हेडर में विभाजन लिखने की आवश्यकता नहीं है (हम पहले से मौजूद कोड की नकल क्यों करेंगे? )। उस मैक्रो को सिस्टम हेडर में परिभाषित किया गया है, इसलिए यदि हम इसका उपयोग करते हैं तो हम उपरोक्त मैक्रोज़ का उपयोग करने के लिए मजबूर हो जाते हैं।
#include <sys/cdefs.h>
#define is_same_type(a, b) __builtin_types_compatible_p(typeof(a), typeof(b))
#define is_array(a) (!is_same_type((a), &(a)[0]))
#define Static_assert_array(a) _Static_assert(is_array(a), "Not a `[]` !")
#define ARRAY_SIZE(arr) ( \
{ \
Static_assert_array(arr); \
__arraycount((arr)); \
} \
)
#define ARRAY_SSIZE(arr) ((ptrdiff_t)ARRAY_SIZE(arr))
#define ARRAY_BYTES(arr) (sizeof((arr)[0]) * ARRAY_SIZE(arr))
कुछ सिस्टम में प्रदान करते nitems()हैं<sys/param.h> बजाय, और कुछ सिस्टम दोनों प्रदान करते हैं। आपको अपनी प्रणाली की जांच करनी चाहिए, और आपके पास जो भी है उसका उपयोग करें, और शायद पोर्टेबिलिटी के लिए कुछ प्रीप्रोसेसर कंडिशनर का उपयोग करें और दोनों का समर्थन करें।
अद्यतन: मैक्रो को फ़ाइल स्कोप पर उपयोग करने की अनुमति दें:
दुर्भाग्य से, ({})फ़ाइल एक्सटेंशन में gcc एक्सटेंशन का उपयोग नहीं किया जा सकता है। फ़ाइल स्कोप पर मैक्रो का उपयोग करने में सक्षम होने के लिए, स्थैतिक अभिकथन अंदर होना चाहिए sizeof(struct {})। फिर, 0परिणाम को प्रभावित नहीं करने के लिए इसे गुणा करें । एक कास्ट (int)एक फ़ंक्शन को अनुकरण करने के लिए अच्छा हो सकता है जो रिटर्न करता है (int)0(इस मामले में यह आवश्यक नहीं है, लेकिन फिर यह कुछ चीजों के लिए पुन: प्रयोज्य है)।
#include <sys/cdefs.h>
#define is_same_type(a, b) __builtin_types_compatible_p(typeof(a), typeof(b))
#define is_array(a) (!is_same_type((a), &(a)[0]))
#define Static_assert_array(a) _Static_assert(is_array(a), "Not a `[]` !")
#define must_be_array(a) ( \
0 * (int)sizeof( \
struct { \
Static_assert_array(a); \
char ISO_C_forbids_a_struct_with_no_members__; \
} \
) \
)
#define ARRAY_SIZE(arr) (__arraycount((arr)) + must_be_array(arr))
#define ARRAY_SSIZE(arr) ((ptrdiff_t)ARRAY_SIZE(arr))
#define ARRAY_BYTES(arr) (sizeof((arr)[0]) * ARRAY_SIZE(arr))