memory allocation in C++ in Hindi

Memory allocation in C++

user input को store करने के लिए हम program में variable declare करते हैं। ये input compile time पर अपने data type के अनुसार memory में space लेते हैं, जिन्हे runtime पर change नहीं किया जा सकता लेकिन dynamic memory का प्रयोग करके, हम run time पर इन input की memory को manipulate कर सकते हैं।

  • एक variable द्वारा ली गई memory program execution के समाप्त होने तक program में बनी रहती है हालाँकि variable जिस task लिए use किया गया था वह task समाप्त हो चूका है ,
  • और चूंकि वे compile time पर memory आवंटित करते हैं, इसलिए हम runtime में उनके size को नहीं बदल सकते हैं, इसका मतलब है कि उनका size stable रहता है।
  • dynamic memory से हमें सुविधा मिलती है, जिसमें हम runtime पर अपनी आवश्यकता के अनुसार memory को (एक सीमा तक )ले सकते हैं और जरूरत खत्म होने पर इसे free भी कर सकते हैं।

Type of memory allocation in C++

Memory allocation C ++ में सबसे महत्वपूर्ण concept है। C ++ में दो तरीके से memory allocate किया जाता है –

  • Static memory allocation
  • Dynamic memory allocation

static memory allocation in C++

  • static memory allocation by default होता है ।
  • इसमें memory allocation compile time पर होता है। इसलिए इसे compile time memory allocation भी कहा जाता है।
  • क्योंकि इसमें memory size fixed होता है,इसलिए इसे static memory allocation भी कहा जाता है।
  • static memory allocation द्वारा allocate की गयी memory de -locate या free होती है जब program terminate हो जाता है।
  • इसका कोई syntax नहीं होता। अर्थात जब हम program में किसी भी variable को declare करते हैं। तो automatic ही memory में space allocate कर लेता है।

तो एक तरह से, variable का normal declaration , एक static memory allocation का उदाहरण है-

int a; char; int arr[5];

ये data types अपने size के अनुसार memory में निम्नलिखित प्रकार से space लेंगे-,

a = 2 bytes;
b = 1 byte

अर्थात,

arr[5] = 10 bytes // 2 byte x 10 = 10
name[10] = 10 bytes // 1 byte x 10 = 10

तो इस प्रकार static memory allocation memory automatic (compile time पर ) memory होता है और automatic ही de -locate (जब Program terminate) हो जाता है। अब तक इस tutorial में दिए गए Programs static memory allocation memory के उदाहरण हैं।

Dynamic memory allocation in C++

  • runtime पर memory allocate करना dynamic memory allocation.कहलाता है।
  • dynamic memory allocation. में, हम runtime पर memory size को बदल सकते हैं (किसी data -type का default size नहीं )और आवश्यकता समाप्त होने पर इसे release भी कर सकते हैं।
  • यहाँ ध्यान दें कि यदि हम dynamically memory allocate करते हैं तो .manually इसे de -locate भी करना होता है। ऐसा नहीं करने की स्थिति में, program में memory leakage की problem हो सकती है।
  • ऐसी static memory allocation में उत्पन्न नहीं होती है क्योंकि वहाँ ममोरी automatic ही de -locate होती है।

क्योंकि यहाँ पर memory allocation runtime पर होता है, इसलिए compile time में memory size का पता नहीं चलता है, यानी runtime पर यह user की requirement पर निर्भर करता है कि कितनी memory को allocate करनी है।

नोट: dynamic memory allocation. में हम runtime पर अलग से कोई variable declare नहीं करते हैं। केवल पहले से declared variable का memory size increase कर देते हैं जो कि data type पर निर्भर करता है।

allocate dynamic memory in Array इसका एक अच्छा उदाहरण है।

allocating dynamic memory in C++

C ++ में, new– operator का प्रयोग करके dynamic memory allocate की जाती है। इसमें memory allocation (new -operator द्वारा) और de -location (delete operator द्वारा), दोनों programmer द्वारा manually किए जाते हैं। क्योंकि यहाँ हम आवश्यकता पड़ने पर runtime में अपनी आवश्यकता के अनुसार memory allocate करते हैं, इसलिए dynamic memory allocation program को flexibility प्रदान करता है।

इसका syntax नीचे दिया गया है –

SYNTAX

data-type pointer-variable = new data-type;

pointer -variable का उपयोग dynamically allocate memory के address को hold करने के लिए किया जाता है, dynamic memory को इसी pointer -variable से access किया जाता है। यहां data type built-in -data type या user defined data type हो सकता है।

new operator

dynamic memory allocation में, सबसे पहले हमें pointer variable declare करते हैं , जो dynamic memory के address को store करता है। ध्यान दें कि memory allocation का data type पर निर्भर करेगा।

उदाहरण के लिए-

int *p;
new int; // allocate 2 byte

फिर, new int के address को *p में असाइन करते हैं –

p = new int;

फिर pointer-variable *p का उपयोग करके value को store किया गया है –

*p = 5;

इन multiple statements को single statement में भी declare किया जा सकता है –

int *p = new int(5);

delete operator

जैसा कि ऊपर बताया गया है, dynamic memory को de-locate करना जरुरी है जिसके लिए delete operator को प्रयोग में लाते हैं इसका syntax नीचे दिया गया है-

SYNTAX

delete pointer-variable;

यहां, pointer variable में केवल pointer variable का नाम होगा यानी memory de-location में pointer variable के साथ asterisk (*) का use नहीं किया जाएगा।

इसका उदाहरण नीचे दिया गया है –

allocate dynamic memory for int data type

#include<conio.h>
#include<iostream.h>

 void main()
 {
   clrscr();
   int *p = new int; // memory allocated at runtime

   *p = 5; //assign value into *p

    cout<<*p; //print

    delete p; // memory release

    getch();
  }

OUTPUT

5

Explanation

program में, new operator से int प्रकार की एक dynamic memory allocate की गयी है। जिसका address एक pointer variable p* में store होता है और अगले statement में value 5 को उस memory में store किया जाता है। memory में store इस value को p* से access किया जाता है। result प्राप्त होने के बाद, dynamic memory को delete operator द्वारा भी de -locate किया गया है।

यहां ध्यान दें यहाँ पर dynamic memory का size केवल 2 bytes होगा क्योंकि हमने int data type को लिया है जिसका memory size 2 bytes होता है।

Free store or Heap

memory दो प्रकार की होती है stack और heap. stack memory program के execution के लिए तथा सभी local variable इसी में स्टोर होते हैं। जहां heap एक unused memory space है, जो stack memory से बड़ा होता है ,जो Program को दिया जाता है। हालाँकि दोनों RAM का हिस्सा हैं। dynamic memory allocation के लिए हम Heap memory का उपयोग करते हैं।

सभी Primitive data type जैसे कि int, char, float, double, long, short stack में store होते हैं जबकि structure, union, array, class या उनके objects heap में store होते हैं जो non -primitive data type हैं। तो अब हम कह सकते हैं,

 static memory allocation  के लिए stack , जबकि free store / heap के लिए dynamic memory allocation इस्तेमाल किया जाता है।

कभी-कभी ऐसा हो सकता है कि heap में पर्याप्त memory space न हो ऐसे में यह एक NULL pointer return करता है।

कई बार dynamic memory allocate करने से या memory leakage से हो सकता है memory overflow हो तो ऐसे में एक program dynamic memory करने से पहले heap में पर्याप्त memory की check करना एक अच्छा अभ्यास है। इसका एक उदाहरण नीचे दिया गया है।

int *ptr=new int;
  
if(!ptr) //ptr==NULL
   cout<<"Can't allocate Memory..!";

इसकी memory को बनाए रखने के लिए, हम dynamic memory को de -locate करते हैं। ताकि execution के दौरान हम इसे किसी और के लिए उपयोग कर सकें या फिर memory leakage से बचे रहें।

कई बार एक program के execution के दौरान, हमें पता नहीं पता होता है कि हमें कितनी memory की आवश्यकता है (जैसे कि एक array में) और execution के समय किसी भी variable को declare भी नहीं किया जा सकता। जो memory की आवश्यकता को पूरा कर सके । ऐसी स्थिति में, हम dynamic memory allocation का use करके इस आवश्यकता को पूरा कर सकते हैं।

जब हम calloc(), malloc() से dynamic memory allocation करते हैं, तो यह उसी के function free() के साथ de-locate होगा। हम delete operator द्वारा calloc() या malloc() से allocated memory de-locate नहीं कर सकते। हां, यह GCC compiler (GNU compiler ) में कहीं संभव हो सकता है। लेकिन आम तौर पर delete operator का उपयोग new operator के साथ किया जाता है।

 heap और stack का size operating system , RAM पर निर्भर करता है।

more about dynamic memory allocation,


previous- Pointer in C++ in hindi

next- string in C++ in hindi

Leave a Reply

Your email address will not be published. Required fields are marked *