किसी ऑब्जेक्ट द्वारा उपयोग की जाने वाली मेमोरी को कैसे ढूंढें

Question

class Help 
{ 
public: 
     Help(); 
     ~Help(); 

     typedef std::set<string> Terms; 
     typedef std::map<string, std::pair<int,Terms> > TermMap; 
     typedef std::multimap<int, string, greater<int> > TermsMap; 

private: 

     TermMap terms; 
     TermsMap termsMap; 
}; 

हम (बाइट्स में) ऑब्जेक्ट term और termsMap द्वारा स्मृति का उपयोग कैसे कर सकते हैं। क्या हमारे पास कोई पुस्तकालय है?

Answer 1

sizeof() ऑपरेटर चाहिए यह करने के लिए:

size_t bytes = sizeof(Help::TermMap); 

Answer 2

आप स्मृति की वास्तविक ब्लॉक के लिए देख रहे हैं, यह करने के लिए एक सूचक के संख्यात्मक मान यह होना चाहिए। (फिर बस बाइट्स की संख्या जोड़ें, और आपके पास ब्लॉक का अंत है)।

Answer 3

यदि आप किसी ऑब्जेक्ट के पूर्ण मेमोरी उपयोग की तलाश में हैं, तो इसे सामान्य रूप से C++ में हल नहीं किया जा सकता है - जबकि हम sizeof() के माध्यम से एक उदाहरण का आकार प्राप्त कर सकते हैं, ऑब्जेक्ट हमेशा आवश्यकतानुसार स्मृति गतिशील रूप से आवंटित कर सकता है ।

आप पता कर सकते हैं कितना बड़ा एक कंटेनर में अलग-अलग तत्व हैं, तो आप एक निचली सीमा प्राप्त कर सकते हैं:

size = sizeof(map<type>) + sum_of_element_sizes; 

ध्यान रखें कि हालांकि कंटेनर अभी भी एक कार्यान्वयन विस्तार के रूप में अतिरिक्त स्मृति आवंटित कर सकते हैं और कि vector और string जैसे कंटेनर के लिए आपको allocated size की जांच करनी होगी।

Answer 4

लघु जवाब: नहीं

लांग उत्तर:
-> बुनियादी वस्तु हाँ। sizeof (< प्रकार >) लेकिन यह केवल सीमित चीजों के लिए उपयोगी है।
-> एक कंटेनर और उसके निहित सदस्य: नहीं

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

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

तो सवाल तब आता है जब आपको आकार जानने की आवश्यकता क्यों है?
क्या आपको वास्तव में आकार (असंभव लेकिन संभव) जानने की आवश्यकता है।

या क्या कोई ऐसा कार्य है जिसे आप प्राप्त करने की कोशिश कर रहे हैं जहां आपको लगता है कि आपको आकार की आवश्यकता है?

Answer 5

हम वस्तुओं अवधि और termsMap द्वारा स्मृति का उपयोग किया ( बाइट में) कैसे पा सकते हैं। क्या हमारे पास कोई पुस्तकालय है?

आपको अपने स्वयं के आवंटक प्रकार का उपयोग करना चाहिए।

typedef std::set<string, 
    your_allocator_1_that_can_count_memory_consumption_t> Terms; 

typedef std::map<string, std::pair<int,Terms>, 
    your_allocator_2_that_can_count_memory_consumption_t> TermMap; 

typedef std::multimap<int, string, greater<int>, 
    your_allocator_3_that_can_count_memory_consumption_t> TermsMap; 

मैं अभी तक std :: स्ट्रिंग के लिए इस विचार की जाँच नहीं की है, इसलिए यदि यह सिर्फ अपने स्वयं के वर्ग fixed_string जो सिर्फ चार रों [अधिकतम स्ट्रिंग-लंबाई] लपेटता का उपयोग लागू करने के लिए मुश्किल है।

और जब आप अपने कार्यक्रम में की जरूरत स्मृति की खपत पता लगाने के लिए सिर्फ your_allocator_1_that_can_counts_memory_consumption_t, your_allocator_2_that_can_counts_memory_consumption_t, your_allocator_3_that_can_counts_memory_consumption_t से समझ गया।

संपादित

UncleBens मैं मेरी बात को स्पष्ट करना चाहते हैं।

जहां तक ​​मैं एआरवी के सवाल को समझता हूं, यह निर्धारित करना आवश्यक है कि सेट :: सेट और std :: मानचित्र के लिए कितनी मेमोरी आवंटित की गई है जिसमें सेट और मानचित्र के तत्वों के लिए आवंटित सभी मेमोरी शामिल हैं। तो यह सिर्फ आकार (शर्तें) नहीं है।

तो मैंने अभी एक बहुत ही सरल आवंटक का सुझाव दिया है। बहुत ज्यादा विवरण में जाने के बिना यह इस प्रकार दिखाई देंगे:

template <class T> 
class your_allocator_1_that_can_counts_memory_consumption_t { 
public: 
    // interfaces that are required by the standart 
private: 
    std::allocator<T> std_allocator_; 
    // here you need to put your variable to count bytes 
    size_t globale_variable_for_allocator_1_to_count_bytes_; 
}; 

यह संभाजक सिर्फ आवंटित और deallocated बाइट्स की संख्या की गणना और वास्तविक आवंटन और आवंटन रद्द करने के लिए अपने सदस्य std_allocator_ का उपयोग करें। मुझे यह सुनिश्चित करने के लिए malloc() और मुफ्त() पर ब्रेकपॉइंट सेट करने के लिए जीडीबी के तहत इसे डीबग करने की आवश्यकता हो सकती है ताकि प्रत्येक आवंटन और डिलीवरी वास्तव में मेरे आवंटक के माध्यम से हो।

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