C++
स्मृति प्रबंधन

वाक्य - विन्यास

• :(( ऑप्ट ) नया ( अभिव्यक्ति-सूची ) ( ऑप्ट ) नया-प्रकार-आईडी नया-प्रारंभिक ( ऑप्ट )
• :(( ऑप्ट ) नया ( अभिव्यक्ति-सूची ) ( ऑप्ट ) ( टाइप-आईडी ) नया-प्रारंभिक ( ऑप्ट )
• :(( विकल्प ) कास्ट-एक्सप्रेशन हटाएं
• :(( ऑप्ट ) हटाएं [] कास्ट-एक्सप्रेशन
• std :: unique_ptr < type-id > var_name (new type-id ( opt )); // सी ++ 11
• std :: share_ptr < type-id > var_name (new type-id ( opt )); // सी ++ 11
• std :: share_ptr < type-id > var_name = std :: make_sared < टाइप-आईडी > ( ऑप्ट ); // सी ++ 11
• std :: unique_ptr < type-id > var_name = std :: make_unique < type-id > ( ऑप्ट ); // सी ++ 14

टिप्पणियों

using IA = int[4];
int* pIA = new IA;
delete[] pIA;  // right
// delete pIA;  // wrong

ढेर

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

int main() {
    int a = 0; //Stored on the stack
    return a;
}

स्टैक को नाम दिया गया है क्योंकि फ़ंक्शन कॉल की श्रृंखलाओं में एक दूसरे के शीर्ष पर उनकी अस्थायी मेमोरी 'स्टैक्ड' होगी, प्रत्येक एक अलग मेमोरी के छोटे खंड का उपयोग करेगा।

float bar() {
    //f will be placed on the stack after anything else
    float f = 2;
    return f;
}

double foo() {
    //d will be placed just after anything within main()
    double d = bar();
    return d;
}

int main() {
    //The stack has no user variables stored in it until foo() is called
    return (int)foo();
}

स्टैक पर संग्रहीत डेटा केवल तब तक मान्य होता है जब तक कि चर आवंटित किया गया क्षेत्र अभी भी सक्रिय है।

int* pA = nullptr;

void foo() {
    int b = *pA;
    pA = &b;
}

int main() {
    int a = 5;
    pA = &a;
    foo();
    //Undefined behavior, the value pointed to by pA is no longer in scope
    a = *pA;
}

नि: शुल्क संग्रहण (ढेर, गतिशील आवंटन ...)

'हीप' शब्द एक सामान्य कंप्यूटिंग शब्द है, जिसका अर्थ स्मृति का एक क्षेत्र है जहाँ से आबंटित की जा सकती है और स्टैक द्वारा प्रदान की गई मेमोरी से स्वतंत्र रूप से निपटा जा सकता है।

C++ में मानक इस क्षेत्र को फ्री स्टोर के रूप में संदर्भित करता है जिसे अधिक सटीक शब्द माना जाता है।

फ्री स्टोर से आवंटित मेमोरी के क्षेत्र उस मूल दायरे से अधिक समय तक रह सकते हैं जिसमें इसे आवंटित किया गया था। स्टैक पर संग्रहित किए जाने वाले डेटा को भी फ्री स्टोर से आवंटित किया जा सकता है।

कच्ची मेमोरी को नए और हटाए गए कीवर्ड द्वारा आवंटित और निपटाया जा सकता है।

float *foo = nullptr;
{
    *foo = new float; // Allocates memory for a float
    float bar;              // Stack allocated 
} // End lifetime of bar, while foo still alive

delete foo;          // Deletes the memory for the float at pF, invalidating the pointer
foo = nullptr;       // Setting the pointer to nullptr after delete is often considered good practice

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

// Allocates memory for an array of 256 ints
int *foo = new int[256];
// Deletes an array of 256 ints at foo
delete[] foo;

मॉलॉक और फ्री के बजाय नए और डिलीट का उपयोग करते समय, कंस्ट्रक्टर और डिस्ट्रक्टर को निष्पादित किया जाएगा (स्टैक आधारित ऑब्जेक्ट्स के समान)। यही कारण है कि नए और डिलीट को मॉलॉक और फ्री में पसंद किया जाता है।

struct ComplexType {
    int a = 0;

    ComplexType() { std::cout << "Ctor" << std::endl; }
    ~ComplexType() { std::cout << "Dtor" << std::endl; }
};

// Allocates memory for a ComplexType, and calls its constructor
ComplexType *foo = new ComplexType();
//Calls the destructor for ComplexType() and deletes memory for a Complextype at pC
delete foo;

स्थान नया

ऐसी स्थितियां हैं जब हम मेमोरी को आवंटित करने के लिए फ्री स्टोर पर भरोसा नहीं करना चाहते हैं और हम new का उपयोग करके कस्टम मेमोरी आवंटन का उपयोग करना चाहते हैं।

इन स्थितियों के लिए हम Placement New उपयोग कर सकते हैं, जहां हम पूर्व-आवंटित मेमोरी स्थान से मेमोरी आवंटित करने के लिए `नए 'ऑपरेटर को बता सकते हैं

उदाहरण के लिए

int a4byteInteger;

char *a4byteChar = new (&a4byteInteger) char[4];

इस उदाहरण में, a4byteChar द्वारा इंगित की गई मेमोरी पूर्णांक चर a4byteInteger माध्यम से 'स्टैक' को आवंटित 4 बाइट है।

इस तरह के मेमोरी आवंटन का लाभ तथ्य यह है कि प्रोग्रामर आवंटन को नियंत्रित करते हैं। उपरोक्त उदाहरण में, चूंकि a4byteInteger को स्टैक पर आवंटित किया गया है, इसलिए हमें 'a4byteChar` को हटाने के लिए एक स्पष्ट कॉल करने की आवश्यकता नहीं है।

गतिशील आवंटित स्मृति के लिए भी समान व्यवहार प्राप्त किया जा सकता है। उदाहरण के लिए

int *a8byteDynamicInteger = new int[2];

char *a8byteChar = new (a8byteDynamicInteger) char[8];

इस स्थिति में, a8byteChar द्वारा मेमोरी पॉइंटर को a8byteChar द्वारा आवंटित डायनेमिक मेमोरी का उल्लेख किया a8byteDynamicInteger । इस मामले में, हालांकि, हमें मेमोरी छोड़ने के लिए delete a8byteDynamicInteger को स्पष्ट रूप से कॉल करने की आवश्यकता है

C ++ क्लास के लिए एक और उदाहरण

struct ComplexType {
    int a;

    ComplexType() : a(0) {}
    ~ComplexType() {}
};

int main() {
    char* dynArray = new char[256];

    //Calls ComplexType's constructor to initialize memory as a ComplexType
    new((void*)dynArray) ComplexType();

    //Clean up memory once we're done
    reinterpret_cast<ComplexType*>(dynArray)->~ComplexType();
    delete[] dynArray;

    //Stack memory can also be used with placement new
    alignas(ComplexType) char localArray[256]; //alignas() available since C++11

    new((void*)localArray) ComplexType();

    //Only need to call the destructor for stack memory
    reinterpret_cast<ComplexType*>(localArray)->~ComplexType();

    return 0;
}