कोई भी दो शैलियों के बीच अंतर पर एक बड़ा लेख लिख सकता है, जो लोग उन्हें घोषित करते समय चर शुरू करते हैं और जो लोग आवश्यक होने पर उन्हें प्रारंभ करते हैं। मैं किसी ऐसे व्यक्ति के साथ एक बड़ी परियोजना साझा करता हूं जो पहली श्रेणी में है और अब मैं निश्चित रूप से दूसरे प्रकार के अधिक हूं। हमेशा वैरिएबल प्रारंभ करने से अधिक सूक्ष्म बग और समस्याएं सामने आई हैं और मैं यह समझाने की कोशिश करूंगा कि मुझे मिलने वाले मामलों को याद क्यों किया जाए। पहले उदाहरण:
struct NODE Pop(STACK * Stack)
{
struct NODE node = EMPTY_STACK;
if(Stack && Stack->stackPointer)
node = Stack->node[--Stack->stackPointer];
return node;
}
यह अन्य पुरुष द्वारा लिखे कोड था। यह फ़ंक्शन हमारे एप्लिकेशन में सबसे गर्म कार्य है (आप एक टर्नरी पेड़ में 500 000 000 वाक्यों पर एक टेक्स्ट इंडेक्स की कल्पना करते हैं, फिर भी एफआईएफओ स्टैक का उपयोग रिकर्सन को संभालने के लिए किया जाता है क्योंकि हम रिकर्सिव फ़ंक्शन कॉल का उपयोग नहीं करना चाहते हैं)। चर की उनके व्यवस्थित प्रारंभिकरण के कारण यह उनकी प्रोग्रामिंग शैली की विशिष्ट थी। उस कोड के साथ समस्या प्रारंभिक के छिपे हुए memcpy और संरचनाओं की दो अन्य प्रतियां थीं (जो बीटीडब्ल्यू को memcpy जीसीसी के अजीब कभी-कभी कॉल नहीं किया गया था), इसलिए हमारे पास 3 प्रतियां थीं + प्रोजेक्ट के सबसे गर्म समारोह में एक छिपी हुई फ़ंक्शन कॉल ।
struct NODE Pop(STACK * Stack)
{
if(Stack && Stack->stackPointer)
return Stack->node[--Stack->stackPointer];
return EMPTY_STACK;
}
केवल एक प्रतिलिपि करने के लिए इसे नए सिरे से लिखना (और स्पार्क पर पूरक लाभ जहां यह चलाता है, समारोह memcpy को बचा कॉल करने के लिए एक पत्ता समारोह धन्यवाद है और एक नया रजिस्टर खिड़की का निर्माण करने की जरूरत नहीं है)। तो समारोह 4 गुना तेजी से था।
एक और समस्या मुझे औंस मिली लेकिन याद नहीं है कि वास्तव में (इसलिए कोई कोड उदाहरण नहीं है, क्षमा करें)। एक वेरिएबल जिसे घोषित किया गया था, लेकिन इसे एक लूप में इस्तेमाल किया गया था, जिसमें switch एक सीमित राज्य automaton में था। समस्या प्रारंभिक मान automaton के राज्यों में से एक नहीं था और कुछ चरम दुर्लभ मामलों में automaton सही ढंग से काम नहीं करता था। प्रारंभकर्ता को हटाकर, उत्सर्जित संकलक ने चेतावनी दी कि यह स्पष्ट रूप से प्रारंभ होने से पहले चर का उपयोग किया जा सकता है। तब automaton फिक्सिंग आसान था। नैतिकता: एक परिवर्तनीय रक्षात्मक रूप से प्रारंभ करने से संकलक की एक बहुत ही उपयोगी चेतावनी दबाने लग सकती है।
निष्कर्ष: बुद्धिमानी से अपने चर शुरू करें। इसे व्यवस्थित करना एक कार्गो-पंथ का पालन करने के अलावा कुछ भी नहीं है (काम पर मेरा दोस्त खराब मालवाहक-कल्पित व्यक्ति कल्पना कर सकता है, वह कभी भी गेटो का उपयोग नहीं करता है, हमेशा एक चर शुरू करता है, बहुत सारी स्थिर घोषणाओं का उपयोग करता है (यह तेज़ है आप जानते हैं (यह तेज़ है तथ्य यह है यहां तक कि वास्तव स्पार्क 64 बिट पर धीमी गति से) में, सभी कार्यों inline बनाता है, भले ही वे 500 लाइनों (__attribute__((always_inline)) का उपयोग करते समय संकलक नहीं चाहता है) है
स्रोत
2010-04-16 18:37:58
केवल कुछ संकेत जो एक ही दिशा में जाते हैं: अपने चर के लिए सबसे छोटे दायरे का उपयोग करें। घोषणा के बाद सीधे शुरू करें। केवल एक उद्देश्य के लिए चर का उपयोग करें। यदि आप अपना चर बदलना नहीं चाहते हैं तो कॉन्स का उपयोग करें मूल्य। इन संकेतों का मुख्य कारण: वे पठनीयता में सुधार करते हैं और आर कोड परिवर्तन के दौरान सूक्ष्म बग के अवसर को प्रेरित करें। कोड इन संकेतों का पालन किए बिना अब बगफ्री हो सकता है - लेकिन उनके बाद प्रत्येक कोड परिवर्तन के साथ इसे बग मुक्त रखना आसान है। –
जब भी संभव हो, एक कथन में परिभाषित करें और आरंभ करें। –
नहीं, अपने चर को प्रारंभ करें जहां यह उचित है। लूप वैरिएबल के लिए लूप वैरिएबल प्रारंभ होने पर लूप के लिए अधिक पठनीय है। लूप से पहले आपका चर घोषित कर दिया गया हो सकता है। शॉर्टलैंड में –