दिलचस्प पोस्ट
यदि मैं इसे स्पष्ट रूप से नहीं करता, तो सी ++ क्लास सदस्यों को कैसे आरंभ किया जाता है? विशेष वर्णों को पकड़ने के लिए regex में त्रुटि अंतिम निकास संहिता के साथ बश संकेत कैसे एक आयात नकली है सीमा वर्ण tesseract के लिए देख रहा है MVC3 और इकाई फ़्रेमवर्क Emacs में स्वागत स्क्रीन छिपाने में असमर्थ एक स्ट्रिंग में एक वर्ण की घटना की गणना लेमान के शब्दों में एसिंक्रोनस कोड को समझना ऑब्जेक्ट की प्रॉपर्टी नाम प्राप्त करना मैं एक YAML फ़ाइल को कैसे पार्स कर सकता हूं? सामग्री में कैरेट (कर्सर) स्थिति प्राप्त करें HTML सामग्री युक्त संपादन योग्य क्षेत्र पेजिंग के साथ UICollectionView – सेटिंग पृष्ठ चौड़ाई JQuery में फ़ाइल इनपुट से डेटा प्राप्त करें जावा: BufferedImage बाइट सरणी और वापस करने के लिए

आप अपने (अप्रबंधित) कोड में मेमोरी लीक का पता कैसे लगा सकते हैं?

अप्रबंधित सी / सी ++ कोड में, मेमोरी लीक का पता लगाने के लिए सर्वोत्तम प्रथाएं क्या हैं? और कोडिंग दिशानिर्देश से बचने के लिए? (जैसे कि यह आसान है;)

हमने अतीत में एक मूर्खतापूर्ण तरीके का इस्तेमाल किया है: प्रत्येक स्मृति आवंटन कॉल के लिए एक वेतन वृद्धि और मुक्त होने पर कमी। कार्यक्रम के अंत में, काउंटर मान शून्य होना चाहिए।

मुझे पता है यह एक शानदार तरीका नहीं है और कुछ कैच हैं। (उदाहरण के लिए, यदि आप एक मंच एपीआई कॉल द्वारा आवंटित की गई स्मृति को खाली कर रहे हैं, तो आपकी आवंटन की गणना आपकी फ्रीिंग गिनती से मेल नहीं खाएगी। बेशक, हम एपीआई कॉल्स को कॉल करते समय काउंटर बढ़ाते हैं।

मैं आपके अनुभवों, सुझावों और संभवत: उपकरण के कुछ संदर्भों की अपेक्षा कर रहा हूं जो इस को आसान बनाते हैं।

Solutions Collecting From Web of "आप अपने (अप्रबंधित) कोड में मेमोरी लीक का पता कैसे लगा सकते हैं?"

यदि आपका C / C ++ code * निकस के लिए पोर्टेबल है, तो कुछ चीजें वालग्रिंड से बेहतर हैं

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

मैं इस लेख के साथ शुरू होगा: https://msdn.microsoft.com/en-us/library/x98tx3cf(v=vs.140).aspx

यहां उन लेखों का त्वरित सारांश है सबसे पहले, ये हेडर शामिल करें:

#define _CRTDBG_MAP_ALLOC #include <stdlib.h> #include <crtdbg.h> 

तब आपको इसे कॉल करने की आवश्यकता है जब आपका कार्यक्रम निकलता है:

 _CrtDumpMemoryLeaks(); 

वैकल्पिक रूप से, अगर आपका कार्यक्रम हर बार उसी जगह से बाहर नहीं निकलेगा, तो आप इसे अपने कार्यक्रम की शुरुआत में कॉल कर सकते हैं:

 _CrtSetDbgFlag ( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF ); 

अब जब प्रोग्राम सभी आवंटन से बाहर निकलता है जो फ्री नहीं थे, तो आउटपुट विंडो में उस फाइल के साथ प्रिंट किया जाएगा, जिसमें वे आवंटित किए गए थे और आवंटन की घटना के दौरान।

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

इसके अलावा संदर्भित एमएसडीएन लिंक में समझाए जाने वाली अन्य तकनीकों को भी इस्तेमाल किया जा सकता है।

सी ++ में: RAII का उपयोग करें स्मार्ट पॉइंटर्स जैसे std :: unique_ptr, std :: shared_ptr, std :: weak_ptr आपके मित्र हैं।

एक सी + + डेवलपर के रूप में यहाँ कुछ बस दिशा निर्देश हैं:

  1. पॉइंटर्स का प्रयोग केवल जब आवश्यक हो
  2. यदि आपको एक संकेतक की आवश्यकता है, तो दो-बार जांच करें कि स्मार्टपॉन्टर एक संभावना है
  3. जीआरएसपी क्रिएटर पैटर्न का प्रयोग करें

स्मृति लीक का पता लगाने के लिए व्यक्तिगत रूप से मैंने हमेशा दृश्य लीक डिटेक्टर का उपयोग किया है और इसे बहुत उपयोगी होने के लिए ढूंढ लिया है।

मैं अब तक कई वर्षों के लिए DevStudio का उपयोग कर रहा हूं और यह हमेशा मुझे आश्चर्यचकित करता है कि कितने प्रोग्रामर स्मृति विश्लेषण टूल के बारे में नहीं जानते हैं जो डिबग रन टाइम लाइब्रेरी में उपलब्ध हैं यहां शुरू करने के लिए कुछ लिंक हैं:

हिएप आबंटन अनुरोधों को ट्रैक करना – विशेष रूप से विशिष्ट आवंटन अनुरोध संख्याओं पर अनुभाग

_CrtSetDbgFlag

_CrtSetBreakAlloc

बेशक, अगर आप DevStudio का उपयोग नहीं कर रहे हैं तो यह विशेष रूप से उपयोगी नहीं होगा

मुझे आश्चर्य है कि कोई भी Windows OS के लिए DebugDiag का उल्लेख नहीं करता है।
यह रिलीज़ बिल्ड पर काम करता है, और यहां तक ​​कि ग्राहक साइट पर भी।
(आपको अपनी रिलीज़ संस्करण पीडीबी को रखने की जरूरत है, और माइक्रोसॉफ्ट पब्लिक सिंबल सर्वर का उपयोग करने के लिए डीबगडिग कॉन्फ़िगर करें)

दृश्य लीक डिटेक्टर एक बहुत अच्छा उपकरण है, लेकिन यह वीसी 9 रनटाइम्स (उदाहरण के लिए एमएसवीसीआरडीडीडीडीएलएलएल) पर कॉल का समर्थन नहीं करता है।

डिबग मोड में माइक्रोसॉफ्ट वीसी ++ मेमोरी लीक से पता चलता है, हालांकि यह नहीं दिखाता कि आपका लीक कहां है।

यदि आप सी ++ का उपयोग कर रहे हैं तो आप हमेशा स्पष्ट रूप से नए प्रयोग से बच सकते हैं: आपके पास vector , string , auto_ptr (पूर्व सी unique_ptr 11; unique_ptr द्वारा सी ++ 11 में unique_ptr ), unique_ptr (सी ++ 11) और shared_ptr unique_ptr (सी ++) 11) अपने शस्त्रागार में

जब नया अपरिहार्य हो, तो उसे कन्स्ट्रक्टर में छुपाने की कोशिश करें (और किसी डिस्ट्रक्टर में डिलीट छिपाएं); तृतीय पक्ष एपीआई के लिए एक ही काम

वहाँ विभिन्न प्रकार के "मॉलोक" पुस्तकालय हैं जो आपको अंत में किसी फ़ंक्शन को कॉल करने की अनुमति देगा और यह आपको सभी अप्रेषित स्मृति के बारे में बताएगा, और कई मामलों में, जो पहली जगह में मॉल (या नये ' ।

यदि आप एमएस वीसी ++ का उपयोग कर रहे हैं, तो मैं अत्यधिक निशुल्क उपकरण को codeproject से सुझा सकता हूं: जेकें कलम्बैक द्वारा लीकफेंडर

आप अपनी प्रोजेक्ट में वर्ग जोड़ सकते हैं, और कॉल करें

 InitAllocCheck(ACOutput_XML) DeInitAllocCheck() 

कोड के पहले और बाद में आप लीक की जांच करना चाहते हैं

एक बार जब आप कोड का निर्माण और चलाते हैं, तो जोकेन एक साफ जीयूआई उपकरण प्रदान करता है, जहां आप परिणामस्वरूप .xmlleaks फ़ाइल लोड कर सकते हैं, और कॉल स्टैक के माध्यम से नेविगेट कर सकते हैं जहां प्रत्येक रिसाव को कोड की अपमानजनक रेखा का शिकार करने के लिए बनाया गया था।

रैशनल (अब आईबीएम के स्वामित्व वाले) प्यूरिफ्टप्लस एक ऐसी ही शैली में लीक को दिखाता है, लेकिन मुझे लगता है कि इसका प्रयोग करने में आसान लीकफाइंडर टूल मिलेगा, इसके बोनस के साथ कई हजार डॉलर खर्च नहीं होंगे!

कभी इसे स्वयं का इस्तेमाल नहीं करते, लेकिन मेरी सी मित्रों ने मुझे शुद्धि कहते हैं ।

यदि आप विजुअल स्टूडियो का उपयोग कर रहे हैं तो यह बाउंड्स चेकर को देखकर लायक हो सकता है। यह मुफ़्त नहीं है, लेकिन मेरे कोड में लीक खोजने में यह अविश्वसनीय रूप से उपयोगी है। यह केवल मेमोरी लीक नहीं करता है, बल्कि GDI संसाधन लीक, WinAPI उपयोग की त्रुटियां और अन्य सामान भी नहीं करता है। यह भी आपको दिखाएगा कि लीक की गई स्मृति को आरंभ किया गया था, जिससे रिसाव को ट्रैक करना बहुत आसान हो गया है।

मुझे लगता है कि इस प्रश्न का कोई आसान जवाब नहीं है। आप वास्तव में इस समाधान का दृष्टिकोण कैसे कर सकते हैं आपकी आवश्यकताओं पर निर्भर करता है क्या आपको क्रॉस प्लेटफ़ॉर्म समाधान की आवश्यकता है? क्या आप नए / हटाना / मॉलोक / मुफ्त (या दोनों) का उपयोग कर रहे हैं? क्या आप वास्तव में सिर्फ "लीक" की तलाश में हैं या आप बेहतर सुरक्षा चाहते हैं, जैसे कि बफर ओवररन्स (या अंडर्रंस) का पता लगाना?

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

मुझे यूनिक्स की मदद के बारे में पर्याप्त जानकारी नहीं है, फिर भी, अन्य लोगों के पास है

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

मैं अतीत में मैंने कुछ समय के लिए कुछ का उपयोग करना चाहूंगा: एक अल्पविकसित रिसाव परीक्षक जो स्रोत स्तर और काफी स्वचालित है मैं इसे तीन कारणों से दे रहा हूं:

  1. आप इसे उपयोगी पा सकते हैं

  2. हालांकि यह एक बिट क्रूटी है, मैं उस शर्मिंदगी मुझे नहीं दूँगी

  3. हालांकि यह कुछ win32 hooks से जुड़ा है, यह कम करना आसान होना चाहिए।

इसमें ऐसी चीजें हैं जिनके इस्तेमाल के दौरान आपको सावधानी बरतनी चाहिए: अंतर्निहित कोड में new पर निर्भर होने के लिए कुछ भी न करें, ऐसे मामलों के बारे में चेतावनियों से सावधान रहें, जो शायद leakcheck.cpp के शीर्ष पर याद हो, यदि आप उस छवि को चालू करें (और उसके साथ किसी भी समस्या को ठीक करें) जो छवि डंप करता है, आप एक बड़ी फ़ाइल बना सकते हैं

डिज़ाइन का मतलब है कि आप चेकर को बिना किसी रीकंपिंग के बदले और बंद कर सकते हैं, जिसमें इसके शीर्ष लेख शामिल हैं Leakcheck.h को शामिल करें जहां आप एक बार जांचना और पुनर्निर्माण करना चाहते हैं। उसके बाद, LEAKCHECK # के साथ या बिना leakcheck.cpp संकलित करें और फिर इसे चालू और बंद करने के लिए रीलिंक करें। Unleakcheck.h भी शामिल है, इसे स्थानीय रूप से एक फ़ाइल में बंद कर देगा। दो मैक्रोज़ प्रदान किए जाते हैं: CLEARALLOCINFO () एक ही फाइल और लाइन की रिपोर्टिंग से अनुपयुक्त होता है जब आप उस कोड को आबंटित करते हैं जिसमें leakcheck.h शामिल नहीं था। ALLOCFENCE () बस किसी भी आवंटन के बिना उत्पन्न रिपोर्ट में एक पंक्ति ड्रॉप।

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

आप इसे यहां पा सकते हैं: http://www.cse.ucsd.edu/~tkammeye/leakcheck.html

लिनक्स के लिए: Google Perftools की कोशिश करें

ऐसे बहुत सारे उपकरण हैं जो समान आवंटित / निःशुल्क गिनती करते हैं, गोओग पेर्फटोल्स के पेशेवर हैं:

  • बहुत तेजी से (वाल्ग्रिंड की तुलना में: बहुत तेज़)
  • परिणामों के अच्छे ग्राफ़िकल प्रदर्शन के साथ आता है
  • अन्य उपयोगी क्षमताएं हैं: सीपीयू-प्रोफाइलिंग, मेमरी-यूज प्रोफाइलिंग …

मैं सॉफ़्टवेयर सत्यापन से मेमोरी वैलिडेटर का उपयोग करने की सलाह दूंगा । यह उपकरण साबित हुआ कि मुझे मेमोरी लीक को ट्रैक करने में मदद करने के लिए और उन अनुप्रयोगों के स्मृति प्रबंधन को बेहतर बनाने में मदद करता है जो मैं काम कर रहा हूं।

एक बहुत ही पूर्ण और तेज उपकरण

क्या आप सभी कॉल्स की गिनती कर रहे हैं और अपने स्वयं के syscall फ़ंक्शन जो कि कॉल रिकॉर्ड करते हैं और फिर वास्तविक फ़ंक्शन को कॉल पास करते हैं?

यह एकमात्र तरीका है कि आप कोड से उत्पन्न कॉल का ट्रैक रख सकते हैं जिसे आपने नहीं लिखा है।

Ld.so के लिए मैन पेज पर नज़र डालें या कुछ सिस्टम पर ld.so.1

Google LD_PRELOAD भी करें और आपको http://www.itworld.com पर तकनीक को समझाते हुए कुछ रोचक लेख मिलेगा।

कम से कम एमएस वीसी ++ के लिए, सी रनटाइम लाइब्रेरी में कई कार्य हैं जो मैंने अतीत में सहायक पाया है। _Crt* फ़ंक्शन के लिए MSDN सहायता की जांच करें

पॉल नेटल का एमएमजीआर मेरा एक लंबा समय पसंदीदा उपकरण है। आप अपने स्रोत फ़ाइलों में mmgr.h को शामिल करते हैं, TEST_MEMORY परिभाषित करते हैं, और यह आपके ऐप के चलाने के दौरान हुई स्मृति समस्याओं से भरा एक पाठ फ़ाइल बचाता है।

सामान्य कोडिंग दिशानिर्देश:

  • संसाधनों को उसी "परत" (फ़ंक्शन / कक्षा / लाइब्रेरी) पर वितरित किया जाना चाहिए जहां उन्हें आवंटित किया गया है।
  • यदि यह संभव नहीं है, तो कुछ स्वचालित डेलोकनेशन का उपयोग करने की कोशिश करें (साझा किए गए पॉइंटर को बढ़ावा दें …)

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

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

इस सूची के शीर्ष पर (जब मैंने इसे पढ़ा) valgrind था Valgrind उत्कृष्ट है अगर आप एक परीक्षण प्रणाली पर रिसाव को पुन: उत्पन्न करने में सक्षम हैं। मैंने इसे बड़ी सफलता के साथ प्रयोग किया है

क्या होगा अगर आपने अभी देखा है कि उत्पादन प्रणाली अभी लीक हो रही है और आपको यह पता नहीं है कि परीक्षण में इसे कैसे पुन: उत्पन्न किया जाए? जो गलत है उसका कुछ प्रमाण उस प्रोडक्शन सिस्टम की स्थिति में कब्जा कर लिया गया है, और यह उस पर एक अंतर्दृष्टि प्रदान करने के लिए पर्याप्त हो सकता है कि समस्या इतनी है कि आप इसे पुन: उत्पन्न कर सकते हैं।

यही वह जगह है जहां मोंटे कार्लो का नमूना चित्र में आता है। रेमंड चेन के ब्लॉग आलेख को पढ़ें, "मेमोरी लीक की पहचान करने का गरीब आदमी का रास्ता" और उसके बाद मेरे कार्यान्वयन को देखें (मान लिया गया लिनक्स, केवल x86 और x86-64 पर परीक्षण किया गया)

http://github.com/tialaramex/leakdice/tree/master

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

वालिगंड लिनक्स के लिए एक अच्छा विकल्प है। MacOS X के अंतर्गत, आप मॉलोक डिब्यूब पुस्तकालय को सक्षम कर सकते हैं जिसमें स्मृति आवंटन समस्याओं को डीबग करने के कई विकल्प हैं (मॉलोक मैनपेज देखें, "पर्यावरण" अनुभाग में संबंधित विवरण हैं)। ओएस एक्स एसडीके में मॉलोकडीबॉग नामक एक उपकरण भी शामिल है (आमतौर पर / डेवलपर / एप्लीकेशन / परफॉर्मेंस टूल / में स्थापित किया गया है) जो उपयोग और लीक की निगरानी में आपकी मदद कर सकता है।

का पता लगाने:

डीबग सीआरटी

से बचें:

स्मार्ट पॉइंटर्स, बोहम जीसी

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

http://www.hexco.de/rmdebug/

मेमोरी डीबगिंग टूल्स सोने में अपने वजन के लायक हैं लेकिन पिछले कुछ वर्षों में मैंने पाया है कि सबसे पहले स्मृति में सबसे अधिक स्मृति / संसाधन लीक को रोकने के लिए इस्तेमाल किया जा सकता है।

  1. संसाधनों के लिए अधिग्रहण कोड लिखने के बाद आप तुरंत आवंटित करना चाहते हैं। इस पद्धति के साथ "भूलना" कठिन होता है और कुछ मायने में किसी को एक तरह से संसाधनों के जीवन चक्र के बारे में गंभीरता से सोचने के लिए मजबूर किया जाता है।

  2. यथासंभव यथासंभव वापसी का उपयोग करें। क्या आवंटित किया जाता है, यदि संभव हो तो एक ही जगह में मुक्त होना चाहिए। संसाधन और रिलीज के अधिग्रहण के बीच सशर्त पथ को यथासंभव सरल और स्पष्ट होना चाहिए।

अधिकांश मेमोरी प्रोमेयरर्स मेरे बड़े जटिल विंडोज़ अनुप्रयोग को धीमा कर देते हैं जहां परिणाम बेकार हैं। एक ऐसा उपकरण है जो मेरे आवेदन में लीक खोजने के लिए अच्छा काम करता है: यूएमडीएच – http://msdn.microsoft.com/en-us/library/ff560206%28VS.85%29.aspx

Mtrace प्रतीत होता है मानक निर्मित एक में लिनक्स के लिए। ये चरण हैं:

  1. बैश में पर्यावरण चर MALLOC_TRACE की स्थापना करें
    MALLOC_TRACE = / tmp / mtrace.dat
    निर्यात MALLOC_TRACE;
  2. आप मुख्य स्रोत फ़ाइल के शीर्ष पर #include <mcheck.h> जोड़ें
  3. Mtrace जोड़ें (); मुख्य और नगर निगम () की शुरुआत में ; नीचे (रिटर्न स्टेटमेंट से पहले)
  4. डिबग जानकारी के लिए -g स्विच के साथ अपने प्रोग्राम को संकलित करें
  5. अपने कार्यक्रम को चलाने
  6. प्रदर्शन के साथ लीक जानकारी
    mtrace your_prog_exe_name /tmp/mtrace.dat
    (मुझे पहले अपने फेडोरा सिस्टम पर पहले mtrace perl स्क्रिप्ट स्थापित करना था yum install glibc_utils )