मेमसेट() या एक संरचना को शून्य करने के लिए मूल्य प्रारंभिकरण?

Question

Win32 एपीआई प्रोग्रामिंग में यह कई क्षेत्रों के साथ सी struct एस का उपयोग करने के लिए विशिष्ट है। आम तौर पर उनमें से केवल कुछ में सार्थक मूल्य होते हैं और अन्य सभी को शून्य करना पड़ता है। यह दो तरीकों में से किसी हासिल किया जा सकता:

STRUCT theStruct; 
memset(&theStruct, 0, sizeof(STRUCT)); 

या

STRUCT theStruct = {}; 

दूसरा संस्करण क्लीनर लग रहा है - यह एक एक लाइनर है, यह कोई पैरामीटर है कि गलत टाइप किया जा सकता है नहीं है और लगाए जा रहे एक त्रुटि का कारण बनता है।

क्या पहले संस्करण की तुलना में इसमें कोई कमी है? उपयोग करने के लिए कौन सा संस्करण और क्यों?

Answer 1

उन दो निर्माणों एक बहुत उनके अर्थ में अलग है। पहले एक एक memset समारोह है, जो करने का इरादा है निश्चित मूल्य को स्मृति का एक बफर सेट का उपयोग करता है। दूसरा एक ऑब्जेक्ट प्रारंभ करें। मुझे कोड का एक सा के साथ यह स्पष्ट करने दें:

चलो मान लेते हैं तो आप एक संरचना केवल पॉड प्रकार

struct POD_OnlyStruct 
{ 
    int a; 
    char b; 
}; 

POD_OnlyStruct t = {}; // OK 

POD_OnlyStruct t; 
memset(&t, 0, sizeof t); // OK as well 

इस मामले में एक POD_OnlyStruct t = {} या POD_OnlyStruct t; memset(&t, 0, sizeof t) ज्यादा फर्क नहीं है लिखने की है कि सदस्य , जैसा कि हमारे पास एकमात्र अंतर है, संरेखण बाइट memset के मामले में शून्य-मान पर सेट किया जा रहा है। चूंकि आपके पास सामान्य रूप से उन बाइट्स तक पहुंच नहीं है, इसलिए आपके लिए कोई अंतर नहीं है।

दूसरी ओर, आप सी ++ के रूप में अपने प्रश्न टैग किया है के बाद से, के पॉड से प्रकार अलग-अलग सदस्य के साथ एक और उदाहरण की कोशिश, चलो: एक अभिव्यक्ति का उपयोग कर TestStruct t = {} की तरह अच्छा है

struct TestStruct 
{ 
    int a; 
    std::string b; 
}; 

TestStruct t = {}; // OK 

{ 
    TestStruct t1; 
    memset(&t1, 0, sizeof t1); // ruins member 'b' of our struct 
} // Application crashes here 

इस मामले में , और memset का उपयोग करके यह क्रैश हो जाएगा। यहां बताया गया है कि यदि आप memset का उपयोग करते हैं तो TestStruct का एक ऑब्जेक्ट बनाया गया है, इस प्रकार यह std::string प्रकार का ऑब्जेक्ट बना रहा है, क्योंकि यह हमारी संरचना का सदस्य है। अगला, memset स्मृति सेट करता है जहां ऑब्जेक्ट b कुछ मान पर स्थित था, शून्य कहें। अब, जब हमारी टेस्टस्ट्रक्चर ऑब्जेक्ट गुंजाइश से बाहर हो जाती है, तो इसे नष्ट किया जा रहा है और जब इसकी बारी std::string b पर आती है तो आपको एक क्रैश दिखाई देगा, क्योंकि उस ऑब्जेक्ट की आंतरिक संरचनाओं को memset द्वारा बर्बाद कर दिया गया था।

तो, वास्तविकता यह है, उन चीजों बहुत अलग हैं, और हालांकि आप कभी कभी memset को कुछ मामलों में शून्य करने के लिए एक पूरी संरचना की जरूरत है, यह हमेशा सुनिश्चित करें कि आप समझते हैं कि आप क्या कर रहे हैं बनाने के लिए महत्वपूर्ण है, और नहीं हमारे दूसरे उदाहरण में गलती करें।

मेरा वोट - वस्तुओं पर memset का उपयोग केवल यदि यह आवश्यक है, और अन्य सभी मामलों में डिफ़ॉल्ट प्रारंभ x = {} का उपयोग करें।

Answer 2

मैं मूल्य प्रारंभिकरण का उपयोग करूंगा क्योंकि यह आपके द्वारा उल्लिखित स्वच्छ और कम त्रुटि प्रवण दिखता है। मुझे ऐसा करने में कोई कमी नहीं दिख रही है।

हालांकि आप उपयोग किए जाने के बाद संरचना को शून्य करने के लिए memset पर भरोसा कर सकते हैं।

Answer 3

यह नहीं कि यह आम है, लेकिन मुझे लगता है कि दूसरे तरीके से फ्लोट को शून्य पर प्रारंभ करने का लाभ भी है। एक मेमसेट करने के दौरान निश्चित रूप से

Answer 4

मूल्य प्रारंभिकता क्योंकि यह संकलन समय पर किया जा सकता है।
यह भी सही ढंग से 0 सभी पीओडी प्रकारों को शुरू करता है।

मेमसेट() रनटाइम पर किया जाता है।
मेमसेट() का भी उपयोग करना संदिग्ध है यदि संरचना पीओडी नहीं है।
गैर इंट प्रकारों को सही ढंग से प्रारंभ नहीं किया जाता है।

Answer 5

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

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

लेकिन यदि इनमें से कोई भी, या एक समान मामला लागू नहीं होता है, तो यह आपके ऊपर निर्भर करता है। मैं, संरचना को परिभाषित करते समय, मूल्य प्रारंभिकता को प्राथमिकता देता हूं, क्योंकि इस उद्देश्य को और अधिक स्पष्ट रूप से संचारित करता है। बेशक, यदि आपको मौजूदा संरचना को शून्यकृत करने की आवश्यकता है, तो memset एकमात्र विकल्प है (ठीक है, प्रत्येक सदस्य को हाथ से शून्य तक शुरू करने के अलावा, लेकिन आमतौर पर ऐसा नहीं किया जाएगा, खासकर बड़ी संरचनाओं के लिए)।

Answer 6

यदि बहुत सारे पॉइंटर सदस्य हैं और आप भविष्य में और अधिक जोड़ने की संभावना रखते हैं, तो यह मेमसेट का उपयोग करने में मदद कर सकता है। उपयुक्त assert(struct->member) कॉल के साथ संयुक्त आप यादृच्छिक क्रैश से बचने के लिए एक खराब सूचक को समझने से बच सकते हैं जिसे आप प्रारंभ करना भूल गए थे। लेकिन अगर आप मेरे जैसे भूल जाते हैं, तो सदस्य-प्रारंभिक शायद सबसे अच्छा है!

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

Answer 7

कुछ कंपाइलर्स में STRUCT theStruct = {}; निष्पादन योग्य में memset(&theStruct, 0, sizeof(STRUCT)); का अनुवाद करेगा। कुछ सी फ़ंक्शंस पहले ही रनटाइम सेटअप करने के लिए जुड़े हुए हैं, इसलिए कंपाइलर में इन लाइब्रेरी फ़ंक्शंस जैसे मेमसेट/मेम्पी का उपयोग करने के लिए उपलब्ध है।

Answer 8

अपने struct तरह बातें शामिल हैं:

int a; 
char b; 
int c; 

फिर गद्दी के बाइट्स "बी" और "सी" के बीच सम्मिलित किया जाएगा। memset() उनको शून्य कर देगा, दूसरा तरीका नहीं होगा, इसलिए कचरे के 3 बाइट होंगे (यदि आपकी चींटियां 32 बिट्स हैं)। यदि आप किसी फ़ाइल से पढ़ने/लिखने के लिए अपनी संरचना का उपयोग करना चाहते हैं, तो यह महत्वपूर्ण हो सकता है।