C ++ के लिए छोटा कॉल स्टैक लॉगर

इस विषय को लिखने के लिए, मुझे " क्या कोड ट्रिक्स पता है? " विषय से संकेत दिया गया था, और मैं इस लकड़हारे को वहां साझा करना चाहता था, लेकिन लेखक ने "कट्टरता के बिना" पूछा, और ऐसी तरकीबें देखना चाहता था, जिन्हें समझने में पाँच से दस सेकंड से अधिक नहीं लगे, इसलिए मैंने इस मामले को एक अलग विषय में रखने का फैसला किया, क्योंकि आप इसे जल्दी से इस तरह नहीं देख सकते।

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

तुरंत सहमत:

1. स्थूल दुरुपयोग बुराई है
2. इस लेख में कुछ भी नया और अलौकिक नहीं है, यह एक शुरुआत के लिए भी स्पष्ट होगा (यह उनके लिए डिज़ाइन किया गया है)
3. यह तकनीक बहु-सूत्रित वातावरण में कम उपयोग (या बिल्कुल भी लागू नहीं) की है
4. कार्यान्वयन सही, पूर्ण और अधिक अद्वितीय होने का दिखावा नहीं करता है
5. यह तकनीक किसी भी तरह से प्रतिस्थापित नहीं करती है, लेकिन केवल डिबगर को पूरक करती है

लेकिन अगर कोई प्रोग्राम लिखते समय आपने एक से अधिक बार प्रिंटफ ("एंटरिंग फू () \ n") जैसा कुछ लिखा हो; किसी विशेष फ़ंक्शन के प्रवेश द्वार की निगरानी करने के लिए, तो आप सिर्फ पते पर आए।

इसलिए, हम इस बहुत ही प्रिंट को परिष्कृत करने का प्रयास करेंगे ("एंटरिंग फू () \ n") और इसमें से अधिकांश को निचोड़ें। पहली बात जो दिमाग में आती है, वह फ़ंक्शन नाम के मैन्युअल टाइपिंग को पूर्वनिर्धारित मैक्रो __FUNCTION__ के साथ बदलना है, जिसमें एक स्ट्रिंग (यानी कास्ट शार्प) होता है जिसमें फ्रेमिंग फ़ंक्शन का नाम होता है:

printf("Entering %s()\n", __FUNCTION__); 

और कोड को नेत्रहीन रूप से अव्यवस्थित नहीं करने और पढ़ने के दौरान विचलित करने वाले कारक नहीं बनाने के लिए, आइए इस बात को मैक्रो के तहत छिपाएं:

 #define LOG_TRACE printf("Entering %s()\n", __FUNCTION__); 

अब, अगर हमारे पास कुछ प्रकार के नूडल-जैसे कोड हैं, तो प्रत्येक फ़ंक्शन की शुरुआत में सावधानी से LOG_TRACE मैक्रो को रखें, हमें कुछ इस तरह मिलता है:

 #include <stdio.h> #define LOG_TRACE printf("Entering %s()\n", __FUNCTION__); void abc() { LOG_TRACE } void foo() { LOG_TRACE abc(); } void bar() { LOG_TRACE foo(); abc(); } int main(int argc, char* argv[]) { bar(); return 0; } 

निष्पादित होने पर, कंसोल प्रदर्शित होगा

 Entering bar() Entering foo() Entering abc() Entering abc() 

पहले से ही कुछ। लेकिन पर्याप्त नहीं है। हालाँकि, अगर हमें याद है कि __FUNCTION__ मैक्रो के अलावा, हमारे पास कोई कम उल्लेखनीय मैक्रोज़ __FILE__ और __LINE__ नहीं है, तो फ़ंक्शन नाम के अलावा, हम फ़ाइल का नाम और लाइन नंबर भी प्रदर्शित कर सकते हैं:

 #define LOG_TRACE printf("Entering %s() (%s:%d)\n", __FUNCTION__, __FILE__, __LINE__); 

 Entering bar() (main.cpp:23) Entering foo() (main.cpp:18) Entering abc() (main.cpp:14) Entering abc() (main.cpp:14) 

पहले से बेहतर - आप तुरंत देख सकते हैं कि कहां देखना है।

हम पूंछ द्वारा बिल्ली को नहीं खींचेंगे और इसे ऐसा करेंगे कि न केवल इनपुट, बल्कि फ़ंक्शन से निकास भी लॉग हो। इस स्तर पर, हम एक आरामदायक छोटे बिशप के साथ भाग लेते हैं और इसके प्लस-आकार की संतानों के लिए आगे बढ़ते हैं।

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

आइए TraceLogger क्लास शुरू करते हैं, जो कंस्ट्रक्टर फ़ंक्शन के प्रवेश द्वार की रिपोर्ट करेगा, और खुशी से विध्वंसक में बाहर निकलने की रिपोर्ट करेगा।

TraceLogger.h:

 class TraceLogger { public: TraceLogger(const char* fileName, const char* funcName, int lineNumber); ~TraceLogger(); private: const char* _fileName; const char* _funcName; }; #define LOG_TRACE TraceLogger traceLogger(__FILE__, __FUNCTION__, __LINE__); 

अब मैक्रो निर्माण में फ़ाइल नाम, फ़ंक्शन नाम और लाइन नंबर के साथ स्टैक पर ऑब्जेक्ट के निर्माण को छुपाता है। हम फ़ाइल के नाम और कार्यों को याद रखेंगे - वे विध्वंसक में उपयोगी होंगे। इस मामले में, आप स्ट्रिंग्स की प्रतियां नहीं बना सकते हैं, लेकिन खुद को उनके लिए संकेत तक सीमित कर सकते हैं, क्योंकि ऑब्जेक्ट का जीवनकाल फ़ंक्शन के शरीर द्वारा सीमित है, और यह इस अवधि के दौरान है कि तार रहते हैं जिसमें __FILE__ और __FUNCTION__ मैक्रोज़ प्रीप्रोसेसिंग के दौरान विस्तारित होते हैं।

विधियों का कार्यान्वयन इस तरह दिखता है:

TraceLogger.cpp:

 TraceLogger::TraceLogger(const char* fileName, const char* funcName, int lineNumber) { _fileName = fileName; _funcName = funcName; std::cout << "Entering " << _funcName << "() - (" << _fileName << ":" << lineNumber << ")" << std::endl; } TraceLogger::~TraceLogger() { std::cout << "Leaving " << _funcName << "() - (" << _fileName << ")" << std::endl; } 

और निष्कर्ष, तदनुसार, यह है:

 Entering bar() - (main.cpp:19) Entering foo() - (main.cpp:14) Entering abc() - (main.cpp:10) Leaving abc() - (main.cpp) Leaving foo() - (main.cpp) Entering abc() - (main.cpp:10) Leaving abc() - (main.cpp) Leaving bar() - (main.cpp) 

इसे देखते हुए, वाक्यांश "काश, मैं इसे इंडेंट कर सकता था!" मेरी जीभ में घूमती है, है ना? कोई सवाल नहीं! हम उस वर्ग का एक स्थैतिक सदस्य बनाएंगे जिसमें हम इंडेंट लाइन (लगभग कई रिक्त स्थान) संग्रहीत करेंगे और हम इसे लॉग लाइन की शुरुआत में प्रदर्शित करेंगे। एक नया उदाहरण बनाते समय (जब आप अगले फ़ंक्शन में प्रवेश करते हैं तो क्या होता है), हम इंडेंटेशन बढ़ाएंगे, और जब यह नष्ट हो जाता है (जब आप फ़ंक्शन से बाहर निकलते हैं तो क्या होता है), हम इसे कम कर देंगे।

TraceLogger.h:

 class TraceLogger { ... private: ... static std::string Indent; }; 

TraceLogger.cpp:

 std::string TraceLogger::Indent; TraceLogger::TraceLogger(const char* fileName, const char* funcName, int lineNumber) { _fileName = fileName; _funcName = funcName; std::cout << Indent << "Entering " << _funcName << "() - (" << _fileName << ":" << lineNumber << ")" << std::endl; Indent.append(" "); } TraceLogger::~TraceLogger() { Indent.resize(Indent.length() - 2); std::cout << Indent << "Leaving " << _funcName << "() - (" << _fileName << ")" << std::endl; } 

और अब हमारा निष्कर्ष इस तरह दिखता है:

 Entering bar() - (main.cpp:19) Entering foo() - (main.cpp:14) Entering abc() - (main.cpp:10) Leaving abc() - (main.cpp) Leaving foo() - (main.cpp) Entering abc() - (main.cpp:10) Leaving abc() - (main.cpp) Leaving bar() - (main.cpp) 

हुर्रे! अब, कार्यक्रम के निष्पादन के दौरान किसी भी समय, आप स्पष्ट रूप से देख सकते हैं कि वर्तमान में हम किस समारोह में हैं और हम वास्तव में वहां कैसे पहुंचे। ठीक है, अगर कुछ गिर गया, तो आप तुरंत देख सकते हैं कि कहां (यहां तक ​​कि जीडीबी को उजागर करने और उसे क्रस्ट खिलाने से पहले)।

और क्या किया जा सकता है? बेशक, रिलीज़ संस्करण में इस सभी गड़बड़ को बंद करें:

TraceLogger.h:

 ... #ifdef DEBUG #define LOG_TRACE TraceLogger logger(__FILE__, __FUNCTION__, __LINE__); #else #define LOG_TRACE #endif 

और अब रिलीज़ संस्करण में हमारे सभी LOG_TRACE कॉर्न खाली हैं। और बाइनरी की शुद्धता को बनाए रखने के लिए, आप पूरी कक्षा को पूरी तरह से काट भी सकते हैं, घोषणा और #ifdef DEBUG के पीछे कार्यान्वयन दोनों को छिपाते हुए - मैं आपको अंतिम रूप देने के लिए इसे छोड़ दूंगा। एक पंक्ति की शुरुआत में टाइमस्टैम्प की तरह, वे भी बहुत उपयोगी हैं।

वह सब है। मुझे उम्मीद है कि कोई इसे उपयोगी पाएगा।

हैप्पी कोडिंग!