2009-09-08 15 views
5

के बारे में "नया" और लॉगिंग डेटा ओवरराइड करना मैं एक मेमोरी प्रोफाइलर लिखने की कोशिश कर रहा हूं और अब तक मेरे कस्टम फ़ंक्शंस को मॉलोक, फ्री, न्यू और डिलीट करने के लिए काम करने में सक्षम हूं। मैंने अधिभारित नई विधि के अंदर उत्प्रेरक को लॉग करने के लिए __FILE__ और __LINE__ का उपयोग करने का प्रयास किया, लेकिन (अपेक्षित के रूप में) यह केवल ओवरलोडेड फ़ंक्शन कहां से ब्योरा देता है। क्या उत्प्रेरक के बारे में विवरण प्राप्त करने का कोई तरीका है बिना ओवरलोड किए गए कार्यों के परीक्षण के घटक के मौजूदा कोड में कोई बदलाव किए बिना (जैसे # malloc के लिए परिभाषित करें)?कॉलर

समारोह मैं उपयोग कर रहा हूँ है:

void* operator new (size_t size) 
{ 
    if(b_MemProfStarted) 
    { 
     b_MemProfStarted = false; 
     o_MemLogFile << "NEW: " << "| Caller: "<< __FILE__ << ":" 
       << __LINE__ << endl; 
     b_MemProfStarted = true; 
    } 

    void *p=malloc(size); 
    if (p==0) // did malloc succeed? 
    throw std::bad_alloc(); // ANSI/ISO compliant behavior 

    return p; 
} 

bool b_MemProfStarted ofstream और map.insert पर पुनरावर्ती कॉल से बचने के लिए किया जाता है।

उत्तर

3

आप

new(foo, bar) MyClass; 

लिख सकते हैं इस मामले निम्नलिखित समारोह कहा जाता है

void*operator new(std::size_t, Foo, Bar){ 
    ... 
} 

अब आप

new(__LINE__, __FILE__) MyClass; 

फोन और

void*operator new(std::size_t, unsigned line, const char*file){ 
    ... 
} 
के साथ डेटा का उपयोग कर सकते में

कोड स्रोत कोड में परिवर्तन की जरूरत के बिना सबसे आमंत्रण पकड़ेगा नजर रखी जा रही करने के लिए एक मैक्रो

#define new new(__LINE__, __FILE__) 

जोड़ा जा रहा है।

यह सही नहीं है क्योंकि आप ऑपरेटर को सीधे उदाहरण के लिए कॉल कर सकते हैं। उस स्थिति में प्रीप्रोसेसर आपके कोड को कूड़ेदान में बदल देगा। हालांकि मुझे कोई बेहतर तरीका पता नहीं है।

+0

'के रूप में, फिर से परिभाषित करने का प्रयास यह एक मैक्रो के साथ अपरिभाषित व्यवहार है (संकलित विशिष्ट एक्सटेंशन को छोड़कर)। मैं 'सामान्य' 'नए' के ​​लिए एक DEBUG_NEW_PLACEMENT मैक्रो को सशर्त परिभाषित करना पसंद करता हूं और स्पष्ट 'ऑपरेटर नया' और विशेष प्लेसमेंट 'अकेले' छोड़ देता हूं। हालांकि, यह अभी भी एक सुंदर समाधान नहीं है। –

+0

शून्य * ऑपरेटर नया (std :: size_t, unsigned line, const char * फ़ाइल) विफल हो जाएगा क्योंकि "नया" सिर्फ size_t लेता है। "# नया नया (__ LINE__, __FILE__)" का उपयोग नहीं कर सकता है और ऑपरेटर एक साथ ओवरराइड करता है क्योंकि यह ओवरराइड फ़ंक्शन परिभाषा में "नया" को प्रतिस्थापित करने का प्रयास करेगा। शून्य * ऑपरेटर नया (std :: size_t) -> शून्य * ऑपरेटर नया (__ LINE__, __FILE __)/* रिकर्सिव? */(Std :: size_t) – Gayan

+0

@ चार्ल्स बेली - क्या आप विस्तृत कर सकते हैं? मैं DEBUG_NEW_PLACEMENT से परिचित नहीं हूं "मैंने नया (आकार) My_New (आकार, __FILE__, __LINE__) परिभाषित किया है" लेकिन ऐसा लगता है कि "नया" – Gayan

0

नहीं, तुम

#define new new(__FILE__, __LINE__) 

नहीं कर सकते, लेकिन आप कर सकते हैं:

#define DEBUG_NEW new(__FILE__, __LINE__) 
#define new DEBUG_NEW 

नज़र में: new` एक कीवर्ड है http://sourceforge.net/projects/nvwa/

संबंधित मुद्दे