एक बूल एक इंट के रूप में ज्यादा स्मृति क्यों लेता है? सी ++

Question

जब मैं देव सीपीपी में इस कार्यक्रम को चलाता हूं, तो टास्क मैनेजर का कहना है कि यह लगभग 7 9 एमबी है। GNU सी ++ 4.7 के साथ Codeforces कहना है कि यह 79,112 किलोबाइट

#include<stdio.h> 
const int N=10010,K=1010; 
struct TPos 
{ 
    int charge; 
    bool ex; 
    TPos() 
    { 
     charge=1<<30; 
     ex=false;  
    } 
}; 
TPos d[N][K]; 

int main() 
{ 
    while(1); 
    return 0; 
} 

लेकिन जब पूर्व parametr टिप्पणी की है:

#include<stdio.h> 
const int N=10010,K=1010; 
struct TPos 
{ 
    int charge; 
    //bool ex; 
    TPos() 
    { 
     charge=1<<30; 
     //ex=false;  
    } 
}; 
TPos d[N][K]; 

int main() 
{ 
    //while(1); 
    return 0; 
} 

यह केवल 39,536 KB है। मैंने सोचा कि बुलियन को एक बाइट का उपयोग करना चाहिए। यह आकार को दोगुना क्यों करता है?

Answer 1

जब तक आप एक संरचना पैक नहीं करते हैं, तब तक यह हमेशा स्मृति ले जाएगा जो शब्द आकार (स्मृति आवंटन के कारण) द्वारा विभाजित है। उदाहरण के लिए जीसीसी में __attribute__(packed) का उपयोग करके आप एक संरचना पैक करते हैं। here भी देखें। एक संरचना पैकिंग आवश्यक स्मृति को कम कर सकता है लेकिन लगभग निश्चित रूप से निष्पादन धीमा कर देगा।

Answer 2

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

इसे अक्षम करने के तरीके पर कंपाइलर विकल्प जांचें, लेकिन ध्यान दें कि प्रदर्शन का सामना करना पड़ सकता है।

Answer 3

मेमोरी संरेखण की वजह से। इस मामले में, bool को struct से int पर गठबंधन किया गया है। मतलब - कुछ अतिरिक्त अप्रयुक्त बाइट्स हैं।

इसका मतलब है, sizeof(your_struct) आपको 2 * sizeof(int) देगा।

आप इस के साथ कुछ प्रयोग कर सकते हैं - यह (एक के बाद एक) के अंदर कुछ और bool रों साथ sizeofstruct ure जाँच, आकार फिर से जांच तत्वों को पुन: क्रम आदि द्वारा इन क्या समझने के लिए उपयोगी प्रयोग हैं हो जाता। इसके अलावा, स्ट्रक्चर पैडिंग और मेमोरी संरेखण के लिए शोध आपके लिए बेहद उपयोगी होगा।

Answer 4

बूल एक बाइट है, लेकिन आप यहां जो देख रहे हैं वह संरचना पैकिंग है।

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

आप संकलक-विशिष्ट प्रागमाओं और विशेषताओं का उपयोग करके संरचना पैकिंग को स्पष्ट रूप से बंद कर सकते हैं, लेकिन आप नहीं चाहते हैं। अगर स्मृति चिंता का विषय है, तो structs की सरणी के बजाय सरणी की संरचना का उपयोग करने पर विचार करें।

Answer 5

यह सच है कि bool आमतौर पर एक बाइट का उपयोग करता है (हालांकि, यह नहीं है)।

हालांकि, सी और सी ++ को पैडिंग जोड़ने के लिए भी अनुमति दी गई है - यानी रिक्त स्थान - संरेखण की अनुमति देने के लिए structs में। यह थोड़ा जटिल है, लेकिन मूल रूप से जब चर सीमाओं को विशेष सीमाओं पर गठबंधन किया जाता है, तो स्मृति पहुंच बहुत तेज हो जाती है।

इस मामले में, अतिरिक्त bool जोड़ने से शायद 4 बाइट्स (केवल int में) 8 बाइट्स तक संरचना आकार में वृद्धि हुई है, इसलिए structs को आपके सरणी के अंदर अच्छी तरह से गठबंधन करने दें।यह सब निश्चित रूप से आपके कंपाइलर पर निर्भर करता है, लेकिन आप चेक करने के लिए sizeof(TPos) का उपयोग कर सकते हैं।

अधिकांश कंप्यूटर्स के पास अनुरोध है कि एक विशेष संरचना पैड हो, भले ही इससे उन्हें उपयोग करने में धीमा हो जाए - आप इसे देखना चाहेंगे।

Answer 6

आप अपनी ऑब्जेक्ट्स के आकार को कम करने के लिए आकार विनिर्देशक का उपयोग कर सकते हैं (निम्नलिखित कोड में : देखें)। इस TPosB दिखाई दे सकता है अगर तुम सच में charge के लिए पूर्ण पूर्णांक आकार की जरूरत नहीं है:

#include <iostream> 

#include<stdio.h> 
struct TPosB 
{ 
    int charge : sizeof(int)-1; 
    bool ex : 1; 
    TPosB() 
    { 
     charge=1 << sizeof(int)-2; 
     ex=false; 
    } 
}; 
TPosB b; 

struct TPos 
{ 
    int charge; 
    bool ex; 
    TPos() 
    { 
     charge=1<<30; 
     ex=false;  
    } 
}; 
TPos a; 

int main() 
{ 
    std::cout << "sizeof(int)" << sizeof(int); 
    std::cout << "\nsizeof(a)=" << sizeof(a); 
    std::cout << "\nsizeof(b)=" << sizeof(b); 

    return 0; 
}