Dynamic Memory Allocation

Dynamic Memory Allocation: Computer में कोई भी Program इसलिए बनाया जाता है ताकि विभिन्न प्रकार के Data को Process किया जा सके और किसी समस्या का समाधान प्राप्त किया जा सके। विभिन्न प्रकार के Data को Memory में Store करने के लिए हम विभिन्न प्रकार के Variables Create करते हैं।

वास्तविक जीवन में हमेंशा ये निश्चित नहीं होता कि कितने Data के साथ प्रक्रिया करनी है। यानी मानलो कि किसी Company में 20 Employee काम करते हैं। उस Company में आवश्‍यकतानुसार किसी Employee को Company से निकाला भी जा सकता है और किसी नए  Employee को Company में Appoint भी किया जा सकता है।

यानी ये निश्चित नहीं होता कि हमेंशा उस Company में 20 Employee ही काम करेंगे। इसलिए यदि किसी Company के Employees का Record रखने के लिए यदि Computer में कोई Program Develop किया जा रहा है तो Computer में भी हम एक निश्चित संख्‍या में Variables Declare नहीं कर सकते।

Computer में भी हमें एक ऐसी व्‍यवस्था की जरूरत होगी जिससे यदि Data बढते हैं तो नए  Variables Create हो सकें और यदि Data घटते हैं तो किसी पुराने Variable को Delete किया जा सके ताकि उस Variable द्वारा Reserve की गई Space का कोई अन्‍य Program उपयोग कर सके।

“C” Language में इस काम को करने के लिए Dynamic Memory Allocation Concept को Use किया जाता है। यानी हम Program में अपनी आवश्‍यकतानुसार Variables Create कर सकते हैं और उन्हें मान प्रदान कर सकते हैं। इस व्‍यवस्था को Dynamic Memory Allocation कहा जाता है।

Dynamic Memory Allocation के लिए “C” में कुछ Memory Management Functions हैं जिनका प्रयोग करके हम Program के Run Time में विभिन्न प्रकार के Variables Create करके उन्हें Memory प्रदान कर सकते हैं। ये Function Memory में Data के लिए Storage Space बनाने या Space हटाने का काम करते हैं।

जब कोई “C” Program Execute होता है, तो “C” Compiler सबसे पहले Static व Global Variables, Permanent Storage Area में अपना Space Reserve करते हैं। फिर Local Variables Memory में अपना Space Reserve करते हैं। Local Variables जो Space Reserve करते हैं, उस Space को Stack कहा जाता है।

Permanent Storage Area और Stack के बीच में हमेंशा कुछ Space बचा रहता है। इस बची हुई Memory Space को Heap कहते हैं। Heap का मान Local Variable पर निर्भर करता है। यानी जब Local Variables Create होता है, तब Heap का मान कम हो जाता है और जब Local Variables Destroy होता है या Local Variable द्वारा Reserve किये गए Memory Space को खाली किया जाता है, तब Heap का मान बढ जाता है। Memory के Management की व्‍यवस्था को निम्नानुसार चित्र से दर्शाया गया है:

Heap Area का मान Variables के Creation व Deletion के अनुसार घटता या बढता रहता है। कई बार ऐसी स्थिति भी आती है कि Heap Area में नया Variable Create करने के लिए Space नहीं बचता। इस स्थिति को Overflow कहते हैं। Overflow की स्थिति में हमेंशा NULL Return होता है।

malloc() Function

इस Function का प्रयोग करके हम Memory का एक Block Create कर सकते हैं और उसे किसी Variable को Allot कर सकते हैं। जब हम Dynamic Memory Allocation के लिए इस Function का प्रयोग करते हैं, तब ये Function Memory में किसी Specified Data Type का एक Memory Block बनाता है और उस Memory Location या इस malloc() Function द्वारा बनाए गए Block Space का Address Return करता है।

इस Address को उसी Data Type प्रकार के Pointer Variable में Store किया जाता है और इस Pointer का उपयोग करके आवश्‍यकतानुसार Data Input किया जाता है। इस Function का Syntax निम्नानुसार होता है-

      ptr = ( Data Type * ) malloc ( sizeof (Data Type ));

ptr

हमें जिस प्रकार के Data के लिए Memory Allocate करनी है, उसी Data Type का ये एक Pointer Variable होता है, जिसमें malloc() Function द्वारा बनाए गए Memory Block का Address Store होता है।

( Data Type * )

हमें जिस प्रकार के Data के लिए Memory Space Allocate करना होता है, उसी प्रकार के Data Type का Address Pointer ptr को Return करना होता है। ये Declaration ptr को Block का Address Return करने का काम करता है।

malloc( sizeof (Data Type))

malloc() Function का प्रयोग Memory में Space Block बनाने के लिए किया जाता है। इस Function में Argument के रूप में ये बताना होता है कि हम जिस प्रकार के Data के लिए Memory में Space Block बनाने जा रहे हैं, वह Data Type Memory में एक Data के लिए कितने Byte लेता है।

जैसे यदि हम int प्रकार के Data के लिए Memory Allocation कर रहे हैं, तो इस Function को बताना होता है कि int प्रकार का Data Type Memory में कितने Byte लेता है।

sizeof Operator का प्रयोग किसी भी Data या Data Type द्वारा Memory में लिए जाने वाले Space की Calculation के लिए किया जाता है। इसीलिए यहां इसका प्रयोग करके malloc() Function को बताया जाता है, कि हम जिस Data Type के लिए Memory Allocation करने जा रहे हैं, वह Data Memory में कितनी Space Reserve करेगा।

Memory Allocation से सम्बंधित सारे Functions “C” की alloc.h नाम की Header File में होते हैं। इसलिए Memory Allocation से सम्बंधित कोई भी काम करने के लिए हमें इस Header File को हमारे Program में Include करना जरूरी होता है।

// Program
#include <stdio.h>
#include <conio.h>
#include <alloc.h>
main()
{
	int *ptr, j, k;
	clrscr();

	// Memory Allocation For Inputting Integers
	ptr = (int * ) malloc (sizeof ( int ) );
	printf("\n Address of Allocated Memory Block is %u", ptr);
	printf("\n How Many Integers You want to Enter?");
	scanf("%d", &j);

	for(k=1; k<=j; k++)
	{
		printf("\n Input %d Integer ", k);
		printf("At Address %u :\t", ptr);
		scanf("%d", ptr);
		ptr++;
	}
	printf("\n Address of Last Allocated Memory Block is %u \n", ptr);
	printf("\n Inputted Integers Are :\n");

	for(k=1; k<=j; k++)
	{
		ptr--;
		printf("\t\n\n %d \t ", *ptr);
		printf("At Address %u  \t", ptr);
	}
	free(ptr);
}

Output 
 Address of Allocated Memory Block is 2050
 How Many Integers You want to Enter?4
 Input 1 Integer At Address 2050 :      12
 Input 2 Integer At Address 2052 :      22
 Input 3 Integer At Address 2054 :      23
 Input 4 Integer At Address 2056 :      36

Address of Last Allocated Memory Block is 2058
Inputted Integers Are :
  36       At Address 2056
  23       At Address 2054
  22       At Address 2052
  12       At Address 2050

आइये अब इस प्रोग्राम का Execution समझते हैं। इस प्रोग्राम में हमें Data, Memory में Space Block को Allocate करके फिर Input करना है, इसलिए alloc.h नाम की Header File को Program में Include किया गया है।

*ptr एक int प्रकार का Pointer Variable है, जिसमें Allocate की गई Space का Address Store करना है, इसलिए इसे Pointer प्रकार का लिया है। चूंकि हमें Program में Integer प्रकार के मान Input करने हैं, इसलिए int प्रकार के मान के लिए निम्नानुसार Memory Allocate की गई है:

      ptr = (int * ) malloc (sizeof ( int ) );

int प्रकार के मान के लिए हमने sizeof(int) लिखा है, जो malloc() को बताता है कि हमें int प्रकार के मान Input करने हैं। इसलिए Allocate किया जाने वाला Memory Block 2 Byte का होना चाहिये। साथ ही जो Memory Block बनता है, उस Memory Block का Address हमें ptr में चाहिये।

हम जानते हैं कि Address हमेंशा Pointer Variable में Store होता है, इसलिए इस Address को प्राप्त करने के लिए हमने (int *) Statement लिखा है। ये Statement Memory में Allocate की गई Memory Block का Address ptr में Store करता है।

इस प्रकार से ptr = (int * )malloc(sizeof (int));  Statement द्वारा int प्रकार के मान के लिए Memory में एक Space Block बनता है और उस Block का Address ptr Pointer Variable को प्राप्त हो जाता है। “Address of Allocated Memory Block is %u ” Statement User को बताता है कि Memory में जो Space बना है, उसका Address क्या है।

अब निम्नानुसार एक Message द्वारा User से ये पूंछा जाता है कि वह कितने मान Input करना चाहता है।

How Many Integers You want to Enter?

यहां User जो भी संख्‍या Input करता है, For Loop को उतनी ही बार चलाया जाता है। अब Loop में संख्‍या Input करने के लिए Message आता है। User जब संख्‍या Input करता है तब वह संख्‍या, उस Allocate की गई Memory Location पर Store हो जाती है।

अगली संख्‍या को Input करने के लिए ptr का Increment किया गया है। अब जब वापस Loop चलता है, तो वापस User से मान मांगा जाता है। ये मान ptr के नए  Address पर Store होता है, क्योंकि ptr को Increment किया गया है।

इस उदाहरण में हम देख रहे हैं कि जो अन्तिम मान User Input करता है, वह मान Memory Address 2056 पर Store हो रहा है, और “Address of Last Allocated Memory Block is 2058” है।

ऐसा इसलिए होता है क्योंकि Loop में दूसरा मान Input करने से पहले ptr के Address को Increment किया गया है। जब हम अन्तिम मान Input कर देते हैं, उसके बाद भी ptr का Increment होता है, जिससे ptr में अन्तिम Address 1058 Store रहता है। लेकिन Loop Terminate हो जाने से इस Location पर कोई मान Store नहीं रहता।

इसलिए ये जरूरी हो जाता है कि Output में इनका मान Print करने से पहले या तो ptr को वही Address प्रदान किया जाए जो कि Memory Allocation के समय था ताकि ptr प्रथम Memory Block के Address से Increment हो और क्रम से हमें सारे Input किये गये मान प्रदान कर दे] या फिर जिस प्रकार से Loop में ptr को Increment करके मान Input किये गए हैं, उसी प्रकार से Loop का मान चला कर ptr को क्रमसे: उल्टे क्रम में Decrement किया जाए और मान Screen पर Print किया जाए।

यहां ptr का अन्तिम मान 1058 है और हमारे मान 2056 तक ही Store हुए हैं, इसलिए सबसे पहले ptr को Decrement किया गया है, फिर क्रम से सारे मान उल्टे क्रम में प्राप्त किये गए हैं। हमने देखा कि सारे मान जिस क्रम में Input किये गए हैं ठीक उसके विपरीत क्रम में प्राप्त किये गए है। इस प्रक्रिया को LIFO ( Last In First Out ) कहा जाता है।

जब Heap Area में Space नहीं होता है तब malloc() Function NULL Return करता है। जिस प्रकार से हमने int प्रकार के मान के लिए Memory में Space बनाया है, उसी प्रकार से किसी भी प्रकार के Data Type के लिए Memory में Space बनाया जा सकता है। जिस Data Type का Memory Block बनाया जाता है उसी Data Type के Pointer Variable को उस Allocated Memory Block के प्रथम Byte का Address प्रदान करना होता है।

यदि हम चाहें तो एक निश्चित Size की भी Space Allocate कर सकते हैं। इस काम के लिए हमें Data Type का मान व उस Data Type के कितने मानों के लिए Space Allocate करनी है, ये दोनों ही Information, Argument के रूप में malloc() Function को देनी होती है। जैसे हमें 7 Characters की एक String के लिए Memory Allocate करनी है तो हमें निम्नानुसार Statement देना होगा-

      cptr =  ( char * ) malloc (7 * sizeof (char ) );

ये Statement 7 Byte की Contiguous Memory Allocate करेगा और इस Memory Block के प्रथम Byte का Address cptr को दे देगा।

Buy this eBook for Complete Discussion about

calloc ( ) Function

free() Function

realloc() Function