Dynamic memory allocation Programming, Data Structures and Algorithms English Malayalam

Dynamic memory allocationYouTube↗ IA↗(long shot)
People & Blogs 819 views 3 likes 0 dislikes 30 Jan 2018

Programming, Data Structures and Algorithms 451 subscribers N/A YouTube↗

ഈ പ്രഭാഷണത്തിലേക്ക് സ്വാഗതം. ഈ പ്രഭാഷണത്തിൽ, ഡൈനാമിക് മെമ്മറി അലോക്കേഷൻ (dynamic memory allocation) എന്ന് വിളിക്കുന്നതിനെക്കുറിച്ചാണ് നമ്മൾ കാണാൻ പോകുന്നത്. അറേകളുടെ (array) വലുപ്പം ഞങ്ങൾക്ക് അറിയാം

Hello all, ah.. welcome back to this lecture. Ah.. in this lecture, we are going to look

അല്ലെങ്കിൽ. നമുക്ക് ആവശ്യമുള്ള വ്യത്യസ്ത സംഖ്യകൾ അല്ലെങ്കിൽ ഫ്ലോട്ടിംഗ് പോയിന്റുകളുടെ

at what is called Dynamic Memory Allocation. So, in all this time so far what we have been

(floating point) എണ്ണം നമുക്കറിയാം, അത് എല്ലായ്പ്പോഴും നിങ്ങൾക്ക് ലഭിക്കുന്ന ഒന്നല്ല. എത്ര സംഖ്യകൾ

looking at is, ah.. we ah.. we know the size of the arrays or we know the number of ah..

വേണം എന്ന് ഉപയോക്താവിനോട് ചോദിക്കേണ്ടി വരും.. ആവശ്യമുള്ള ഘടകങ്ങളും അതിന്റെ അടിസ്ഥാനത്തിൽ

different integers we want or the number of floating points, we want and so on, and thats

ഉചിതമായ വലുപ്പത്തിലുള്ള അറേകൾ (array) അനുവദിക്കും . ഈ മൊഡ്യൂളിൽ (module) നമ്മൾ

not always something that you get. So, many times you you may want to ask the user, how

കാണാൻ പോകുന്നത് ഡൈനാമിക് മെമ്മറി അലോക്കേഷന്റെ (dynamic memory allocation) ആശയമാണ്.

big ah.. the num the number of ah.. elements you want and based on that you want to allocate

ആവശ്യാനുസരണം മെമ്മറി (memory) അനുവദിക്കാൻ കഴിയുന്ന വിവിധ പ്രോഗ്രാമിംഗ് (programming) ഭാഷകളിൽ ഇത് ചെയ്യാൻ പറ്റും. പ്രോഗ്രാമിന് (program)

arrays of an appropriate size and such. So, in this ah.. ah.. lecture module what

ആവശ്യമാണെങ്കിൽ മെമ്മറി (memory) അനുവദിക്കും, ആവശ്യമില്ലാത്തപ്പോഴെല്ലാം മെമ്മറി (memory) വീണ്ടും

we are going to look at is the notion of dynamic memory allocation. Its so fundamental ah..

വീണ്ടെടുക്കേണ്ടതുണ്ട്. ഈ പ്രഭാഷണത്തിലേക്ക് വരാൻ, പോയിന്ററുകൾ (pointer) എന്താണെന്നതിനെക്കുറിച്ച് നിങ്ങൾക്ക് ന്യായമായ ധാരണ ഉണ്ടായിരിക്കണം..

to ah.. various programming languages to be able to allocate memory only on demand. Only

ഞാൻ സംസാരിച്ച ആദ്യത്തെ കാര്യങ്ങളുടെ ഇടത്തിലേക്ക് മടങ്ങാം, സ്ഥലം അനുവദിക്കുക എന്ന ആശയം. ഏതെങ്കിലും

if the program needs it, ah.. you allocate memory and whenever you don't need it that

ഡാറ്റാ തരത്തിന്റെ വേരിയബിൾ (variable) ഡിക്ലയർ (declare) ചെയ്യുമ്പോൾ അതിനായി സ്ഥലം അനുവദിക്കും.

memory has to be reclaimed back and so on. So, ah.. to come to this lecture, you should

മെമ്മറിയുടെ (memory) അളവ് എടുക്കുകയും ഒരു നിശ്ചിത ശ്രേണി ബൈറ്റുകൾ (byte) റിസർവ്

have a reasonable understanding of what pointers are... And if you have not ah.. gone through

(reserve) ചെയ്യുകയും ഈ വേരിയബിളിന് (variable) ഇത് ഉപയോഗപ്രദമാണെന്നും മറ്റ് വേരിയബിളുകൾക്ക്

the lecture on pointers, so I strongly suggest that you go and review the lectures on pointers,

(variable) ആ ലൊക്കേഷൻ (location) ഉപയോഗിക്കാൻ കഴിയില്ലെന്നും പറയുക. ഇതാണ് ഞങ്ങൾ ഇതുവരെ ചെയ്യുന്നത്.

before you come back here.

എനിക്ക് int x അല്ലെങ്കിൽ float y എന്നിങ്ങനെയുള്ളപ്പോഴെല്ലാം,

So, lets go back to the very first set of things that I talked about, the notion of

ഒരു പ്രത്യേക കൂട്ടം ബൈറ്റുകൾ (byte) ഉണ്ടെന്ന് ഞങ്ങൾ അനുമാനിക്കുന്നു, ഇത് ഇതിനകം തന്നെ കംപൈലർ (compiler ) അനുവദിച്ചത് ആണ്. ചിലപ്പോൾ നിങ്ങൾ

allocation of space. So, whenever we declare a variable of any data type, there is allocation

ഈ ഡാറ്റാ (data) തരങ്ങൾ നോക്കുമ്പോൾ ശരിയാണ്,

of space done to that. So, you take the amount of memory that is there and you go and reserve

ഒരാൾക്ക് ചോദിക്കാൻ കഴിയുന്ന രണ്ട് ചോദ്യങ്ങളുണ്ട്, കൂടാതെ ഇവ രണ്ടും ഒന്നല്ല, അവ ബന്ധപ്പെട്ടിരിക്കുന്നു, പക്ഷേ അവ സമാനമല്ല. അനുവദിക്കാനുള്ള വലുപ്പം എപ്പോഴാണ് ഞങ്ങൾ അറിയുക? ഞാൻ

a certain sequence of bytes and say that this is useful for this variable and no other variable

നിങ്ങളോട് int ചോദിച്ചാൽ, എനിക്ക് int x ഉണ്ടെങ്കിൽ, അനുവദിക്കേണ്ട വലുപ്പം അറിയാമോ, ഞാൻ int x വ്യക്തമാക്കിയാൽ,

can use this ah.. location. This is what we have been doing so far right. Whenever I have

ഒരു പൂർണ്ണസംഖ്യയ്ക്കായി സ്ഥലം റിസർവ് (reserve) ചെയ്യണമെന്ന് എനിക്കറിയാം. ഞാൻ int a[10] കൊടുത്താൽ

int x or float y and so on, we assume that there is a particular set of bytes, its already

10 ഘടകങ്ങളുടെ ഒരു അറേ (array) ആണ് വേണ്ടത്.

allocated by the compiler to go and ah.. for you to go and use. So, sometimes right when

എനിക്ക് ആവശ്യമുള്ള വലുപ്പം എനിക്കറിയാം. എന്നാൽ ഇത് യഥാർത്ഥത്തിൽ സ്ഥലം അനുവദിക്കുന്നതിന് തുല്യമല്ല. അനുവദിക്കേണ്ട ഇടം എനിക്കറിയാമെങ്കിൽ, എനിക്ക് പെട്ടെന്ന് സ്ഥലം അനുവദിക്കേണ്ടതില്ല,

you look at these data types, ah.. there are two questions that one could ask, and these

പ്രോഗ്രാം (program) പ്രവർത്തിക്കാൻ തുടങ്ങുമ്പോൾ അത് അനുവദിക്കാം. അതിനാൽ, സാധ്യമായ രണ്ട് സമയങ്ങളിൽ

two are not the same, they are related, but they are not the same. When do we know the size to allocate right? So, if I ask you int, if I have int comma int x right, do we know

എനിക്ക് ഇത് ചെയ്യാൻ കഴിയും, ഒന്നിനെ കംപൈൽ ടൈം (compile time) അല്ലെങ്കിൽ സ്റ്റാറ്റിക് അലോക്കേഷൻ (static allocation) എന്നും മറ്റൊന്ന് റൺ ടൈം (run time) അല്ലെങ്കിൽ ഡൈനാമിക് അലോക്കേഷൻ (dynamic allocation) എന്നും വിളിക്കുന്നു.

സാധാരണയായി അനുവദിക്കേണ്ട വലുപ്പം നിങ്ങൾക്കറിയാമെങ്കിൽ,

the size that we have to allocate, yes if I specify int x I know that I have to reserve

സ്റ്റാറ്റിറ്റിക്കായി (static) എത്രമാത്രം വകയിരുത്തണം, നിങ്ങൾ അലോക്കേഷനും (allocation) സ്റ്റാറ്റിക്കലായി (statical) ചെയ്യും. എന്നിരുന്നാലും, നിങ്ങൾക്ക് ആവശ്യമുള്ള

space for an integer right. If I to if I do int of a comma a of 10, I

അറേയുടെ (array) വലുപ്പവും മറ്റും അറിയില്ലെങ്കിൽ, പ്രോഗ്രാം (program) പ്രവർത്തിക്കാൻ തുടങ്ങുന്നതുവരെ കാത്തിരിക്കണം. പ്രോഗ്രാം (program) പ്രവർത്തിക്കാൻ

want a to be an array of size 10 elements. So, I do know the size that I want. But this

തുടങ്ങുമ്പോൾ, എത്ര വേണമെന്ന് ഉപയോക്താവിനോട് ചോദിക്കേണ്ടി വന്നേക്കാം. അതിന്റെ അടിസ്ഥാനത്തിൽ പ്രോഗ്രാമർ (programmer) ശരിയായി ആഗ്രഹിക്കുന്നത്ര ബൈറ്റുകൾക്കായി (byte) മാത്രം റിസർവേഷൻ

is not the same as actually allocating space right. So, if I know the space that has to

(reservation) ചെയ്യുന്ന ഒരു സംവിധാനം നിങ്ങൾക്ക് ആവശ്യമാണ്. അതിനെ ഡൈനാമിക് മെമ്മറി അലോക്കേഷൻ (dynamic memory allocation) എന്ന് വിളിക്കുന്നു.

be allocated, I don't have to immediately allocate the space, I can allocate it, when

പ്രക്രിയ എങ്ങനെ പോകുന്നുവെന്ന് നോക്കാം. ഈ ഉദാഹരണം കാണാം, char c. ഒരു കംപൈലർ (compiler)

the program starts running right. So, I could do it at two possible times, one is called

നോക്കുന്ന നിമിഷം, അതിന് ഒരു ബൈറ്റ് (byte) മാത്രമേ ആവശ്യമുള്ളൂവെന്ന് അറിയാം, കാരണം കാരക്ടറുകൾക്കു

compile time or static allocation, and another is called run time or dynamic allocation right.

(character) ഒരു ബൈറ്റ് (byte) മാത്രമേ ആവശ്യമുള്ളൂ. എന്നാൽ Int array[10] എന്ന അറേ ഡിക്ലറേഷൻ (array

So, generally if you know the size that has to be allocated, which means if you know ah..

declaration) ഉണ്ടെങ്കിൽ, നിങ്ങൾക്ക് ഒരു സംഖ്യക്കു 4 ബൈറ്റുകൾ 9byte) വേണം, 10 തവണയായി, അതായത് കുറഞ്ഞത് 40 ബൈറ്റുകളെങ്കിലും (byte) ആവശ്യമാണ്. വലുപ്പം

statically how much has to be allocated, you would also do the allocation statically. However,

അറിയാമെങ്കിൽ, സ്ഥലം അനുവദിക്കുന്നതും നല്ലതാണ്. പ്രോഗ്രാം (program) പ്രവർത്തിക്കാൻ തുടങ്ങിയ ഉടൻ തന്നെ, നിങ്ങൾക്ക് 41 ബൈറ്റുകളും

if you don't know the size of the array that you want and so on right, you have to wait

(byte), കാരക്ടർ (character) c ക്കു 1 ബൈറ്റും (byte)

till the program starts running. When the program starts running, you may have to ask

0 മുതൽ 9 വരെയുള്ള അറേയ്‌ക്ക് (array) 40 ബൈറ്റുകളും (byte) അനുവദിക്കും. എന്നിരുന്നാലും,

the user how much you want. Based on that you need a mechanism by which you make reservation

എത്ര മെമ്മറി (memory) അനുവദിക്കണമെന്ന് ചിലപ്പോൾ ഞങ്ങൾക്ക് അറിയില്ല. എനിക്ക് int *array, ഉണ്ടെങ്കിൽ, അറേ (array) എത്ര വലുതാണെന്ന്

for only as many bytes as the programmer wanted right. So, that is called dynamic memory allocation.

അറിയില്ലായിരിക്കാം, ഇത് ഒരു പൂർണ്ണസംഖ്യയിലേക്കുള്ള പോയിന്റർ (pointer) ആണോ, ഇത് 10 പൂർണ്ണസംഖ്യകൾ, 100 സംഖ്യകൾ, 1 ദശലക്ഷം സംഖ്യകൾ എന്നിവയിലേക്കുള്ള

And lets see, what ah.. how the process goes.

പോയിന്ററാണോ, ഇത് ഇതുവരെ ശരിയായി അറിയില്ല.

So, lets see this example, character c. The moment I a compiler looks at it, it knows

എന്നാൽ നമുക്കറിയാവുന്നത്, ഈ ഘട്ടത്തിൽ ഒരു പൂർണ്ണസംഖ്യയിലേക്കുള്ള പോയിന്റർ (pointer) ആണെന്ന് നമുക്കറിയാം. ഇത് എങ്ങനെ ഉപയോഗിക്കും?

that it needs only one byte, because characters required only one byte. However, if you have

ഇ തിനകം അനുവദിച്ച ഒരു കാര്യത്തിലേക്ക് എനിക്ക് അറേ (array) പോയിന്റ് (point) ചെയ്യാനാകുമെന്ന്

a declaration of size int array of 10, so you need an integer is 4 bytes typically and that into 10 times, you need at least 40 bytes right. If the size is known, its generally

ഉണ്ടെങ്കിൽ int *array. എനിക്ക് ഇതുപോലൊന്ന് ഉണ്ടായിരിക്കാം. Int b[10] ഈ ഡിക്ലറേഷൻ (declaration) ഉണ്ടായിരുന്നുവെന്ന് പറയാം. b ഇതിനകം തന്നെ 10 മുതൽ 4, 40 ബൈറ്റുകൾ (byte) വരെ അതിന്റെ സ്ഥലം

അനുവദിച്ചിട്ടുണ്ട്, കൂടാതെ എനിക്ക് അറേ (array) b യിലേക്ക് പോയിന്റ് (point) ചെയ്യാനാകും.

also good to go and allocate the space. As soon as the program starts running, you will

എനിക്ക് 10 പൂർണ്ണസംഖ്യകളുള്ള b ഉണ്ട്, അതിലേക്ക്

have 41 bytes allocated, 1 byte for character c and another 40 bytes for array of 0 to array

എനിക്ക് അറേ (array) പോയിന്റ് (point) നൽകാം. അത് b യുടെ 0 ആം സ്ഥാനത്തേക്ക് പോയിന്റു (point) ചെയ്യും.

of 9. However, sometimes we do not know how much

ഈ സാഹചര്യത്തിൽ അലോക്കേഷൻ (allocation) ഇതിനകം തന്നെ നടത്തിയിട്ടുണ്ട്, പക്ഷേ പ്രഖ്യാപനം

memory to allocate. So, if I have int star array, we may not know how big the array is

നടക്കാത്ത സ്ഥലങ്ങളും ഉണ്ട്. ഏത് സാഹചര്യത്തിലും, നിങ്ങൾ പോയി പ്രഖ്യാപിക്കണം അല്ലെങ്കിൽ നിങ്ങൾ പോയി മെമ്മറി (mmeory) ക്ലെയിം (claim ചെയ്യണം,

going to be. So, its a pointer to an integer right now. So, is it pointer to just one integer,

നിങ്ങൾ പുതിയ മെമ്മറി (memory) അനുവദിക്കുകയും ആ ഇടം നിങ്ങളുടേതാണെന്ന് അവകാശപ്പെടുകയും വേണം. മുമ്പത്തെ ഒരു പ്രഭാഷണത്തിൽ

is it is it a pointer to 10 integers, 100 integers, 1 million integers, we don't know

നിന്ന് നിങ്ങൾ ഓർത്തിരിക്കേണ്ട കാര്യമാണിത്. int *p , p എന്നത് ഒരു പോയിന്റർ വേരിയബിൾ (pointer variable)

that yet right. But all we know is, at this point of time we know that its a pointer to

മാത്രമാണ് എന്ന് ഞാൻ പറഞ്ഞപ്പോൾ, അത് ഒരു പൂർണ്ണസംഖ്യ അനുവദിക്കുന്നില്ല.

a pointer to an integer right. So, how do we use this?

ഇത് ഒരു പോയിന്റിനെ (pointer) മാത്രമേ അനുവദിക്കുകയുള്ളൂ, അത് ഇന്റിജെറിലേക്ക് (integer) പോയിന്റ് (point) ചെയ്യാൻ കഴിയും, പക്ഷേ ഇന്റിജെർ (integer)

So, int star array if I have that I could make array point to something that is already

അലോക്കേറ്റ് (allocate) ചെയ്തിട്ടില്ല. int സ്റ്റാർ അറേ (array) എല്ലാം ഇതിനകം അനുവദിച്ച ഒന്നിലേക്ക് പോയിന്റ് (point) ചെയ്യേണ്ടതായി

allocated. So, I may have something like this. So lets say I had a declaration of this form

വന്നേക്കാം, പക്ഷേ ഇതിനകം അലോക്കേറ്റ് (allocate) ചെയ്തിട്ടുണ്ടെങ്കിൽ, അതിന്റെ വലുപ്പം ഞാൻ അറിഞ്ഞിരിക്കണം. ഇത് ഒരു ലൂപ്പിലേക്ക്

int b of 10. So, b is already allocated its space for 10 into 4, 40 bytes at least and

(loop) പ്രവേശിക്കുന്നു, നേരത്തെ തന്നെ വലുപ്പം അറിയേണ്ടതുണ്ട്. നമുക്ക് വേണ്ടത് വലുപ്പം അറിയപ്പെടാത്ത ഒരു മെക്കാനിസമാണ് (mechanism), പ്രോഗ്രാം (program) പ്രവർത്തിക്കാൻ

തുടങ്ങുമ്പോൾ പ്രോഗ്രാമിന്റെ (program) റൺ (run) സമയത്ത്

I could make array point to b. So, I have b which is of 10 integers and I could make

മാത്രമേ വലുപ്പം അറിയാൻ കഴിയൂ, ഒപ്പം വലുപ്പം ഉചിതമായി അലോക്കേറ്റ് (allocate) ചെയ്യാനും ആഗ്രഹിക്കുന്നു. മാലോക്ക് (malloc) എന്ന് വിളിക്കുന്ന ഒരു

array point to that. So, when you make it point to that it will point to the 0th location

ഫംഗ്ഷൻ ഉണ്ട്. മാലോക്ക് (malloc) സി (C) യിലെ ഒരു ഫംഗ്ഷനാണ് (function), ഒരു ഇൻറിജർ (integer) അതിന്റെ

of b. So, in this case allocation is already done,

ഇൻപുട്ടായി (input) എടുക്കാം, ഒരു പോയിന്റർ (pointer)

but there are also places, when the declaration is not done. In in which case, you have to

അതിന്റെ ഔട്ട്‌പുട്ടായി (output) നൽകുന്നു, ഈ ഫംഗ്ഷൻ (function) stdlib.h ലൈബ്രറി ഫയലിൽ (library file) ആണ് ഉള്ളത്.

go and declare or you have to go and claim memory, you have to allocate new memory and

ഇത് ഇതിനകം നിങ്ങൾക്ക് ഒരു ലൈബ്രറിയായി

claim that ah.. space to be yours right now. So, this is something that you have to you

(librray) നൽകിയിട്ടുണ്ട്, നിങ്ങളുടെ മാലോക്കിന്റെ (malloc) പതിപ്പ് എഴുതേണ്ടതില്ല. stdlib- ൽ ഇതിനകം നിർവചിച്ചിരിക്കുന്ന ഒരു ഫംഗ്ഷനാണ് (function) malloc. അത് ചെയ്യുന്നത്

probably remember from an earlier lecture. So, when I said something like int star p

ഇനിപ്പറയുന്നതാണ്. നിങ്ങൾ‌ അതിലേക്ക് ഒരു വലുപ്പം നൽ‌കുന്നു, നിങ്ങൾ‌ക്കാവശ്യമുള്ള ബൈറ്റുകൾ‌ (byte) നിങ്ങൾ‌ നൽ‌കുന്നു. എനിക്ക്

right, p is just a pointer variable, it does not allocate an integer.

10 പൂർണ്ണസംഖ്യകൾ വേണമെന്ന് പറയാം, ഓരോ സംഖ്യകളും 4 ബൈറ്റുകളാണ് (byte), ഞാൻ 40 പാസ് (pass) ചെയ്യ്യും.

It only allocates a pointer which can point to some integer right, but the integer itself

അത് 10 x 4 ആണ്. മാലോക്ക് (malloc) എന്തുചെയ്യും, മെമ്മറി (memory) സ്കാൻ (scan) ചെയ്യും, ഉപയോഗിക്കാത്ത

is not allocated. So, int star array may have to be pointed to something that is all already

ഇടമുണ്ടോ എന്ന് കണ്ടെത്തുക. 40 ബൈറ്റുകളുടെ (byte) ഉപയോഗിക്കാത്ത ഇടത്തിന്റെ തുടർച്ചയായ ഭാഗമുണ്ടെങ്കിൽ,

allocated, but if its already allocated, I should know the size. So, this gets into a

അത് ഇപ്പോൾ നിങ്ങൾക്കാവശ്യമുള്ള ഒരു ഇടമായി ക്ലെയിം (claim) ചെയ്യുകയും അത് നിങ്ങൾക്ക് തിരികെ നൽകുകയും ചെയ്യും. എനിക്ക് ഒരു വലിയ

loop, this gets into a problem of find, knowing the size ahead of time. So, what we want is

മെമ്മറി (memory) ഉണ്ടെങ്കിൽ എനിക്ക് ഒരു വലിയ അറേ (array) ഉണ്ടെങ്കിൽ, മെമ്മറിയുടെ (memory)

a mechanism by which the size may not be known and during the run time of the program when

ചില ഭാഗങ്ങൾ ഇതിനകം എടുത്തിട്ടുണ്ട്, ചില ഭാഗങ്ങൾ ഇല്ല. മാലോക്ക് (malloc) വിളിക്കുമ്പോൾ, ഞാൻ അതിനെ 40 ഉപയോഗിച്ച് വിളിച്ചുവെന്ന്

the program already starts running, only then you get to know the size and you want to allocate

പറയട്ടെ. 40 ബൈറ്റുകൾ (byte) അനുവദിക്കണമെന്ന് ഞാൻ ആഗ്രഹിക്കുന്നു, അത് പോയി ആദ്യത്തെ

size as appropriately.

സ്വതന്ത്ര ഇടം നോക്കി ചോദിക്കും, ഈ സ്ഥലത്ത്

So, to do that there is a function called malloc or m alloc as some people would call

40 ബൈറ്റുകൾ (byte) ഉണ്ടോ? ഇല്ല എന്ന് ഉത്തരം ഉണ്ടെങ്കിൽ, അലോക്കേഷൻ (allocation) നടക്കാത്ത ഇടങ്ങളിലെല്ലാം

it. So, malloc is a function in C and it can take an integer as its input and it returns

അത് പോയി അടുത്ത വൈറ്റ് സ്പേസ് (white space) നോക്കും, അവിടെ 40 ബൈറ്റുകൾ (byte) ഉണ്ടോ? തുടർച്ചയായി 40 ബൈറ്റുകളുള്ള (byte) കുറച്ച് സ്ഥലം ഇത് കണ്ടെത്തുന്നു, അത് കോളറിലേക്ക്

a pointer as its output and this function is ah.. in this library file called stdlib

(caller) ഒരു പോയിന്റർ (pointer) നൽകും. ഇത് ഒരു വോയിഡ് പോയിന്റർ (void pointer) ആണ്. അതിനർത്ഥം, ഡാറ്റാ (data) തരം പ്രധാനമല്ല, ഞാൻ നിങ്ങൾക്ക് ഇടം

dot h. So, its already given as a library to you, you don't have go and write your version

നൽകി. എന്നിട്ട്, അത് എടുത്ത് ഒരു പൂർണ്ണസംഖ്യയിലേക്കോ അല്ലെങ്കിൽ ഒരു കാരക്ടർ പോയിന്ററിലേക്കോ (character pointer) ടൈപ്പ്കാസ്റ്റ്

of malloc. So, malloc is a function that is already defined in stdlib for you. What it

(tyecast) ചെയ്യേണ്ടത് നിങ്ങളാണ്. ഈ സാഹചര്യത്തിൽ ഞങ്ങൾ 40 int 40 ബൈറ്റുകൾ (byte) ചോദിച്ചു, 40 ബൈറ്റുകളിലേക്ക്

does is as follows. You pass a size to it, you pass a number of

(byte) ഒരു പോയിന്റർ (pointer) ലഭിക്കും. നിങ്ങൾ അത് ഒരു * ലേക്ക് ഒരു പോയിന്റർ (pointer)

bytes that you want. Lets say I want 10 integers right, each integers is of 4 bytes, I will

ആക്കുന്നു, ഇത് അർത്ഥമാക്കുന്നത്, നിങ്ങൾക്ക് ഒരു പോയിന്റർ (pointer) ഉണ്ട്, അത് ഒരു പൂർണ്ണസംഖ്യ പോയിന്റർ (pointer) ഡാറ്റ (data) തരമാണ്. ഇടതുവശത്ത്, നിങ്ങൾക്ക്

pass 40 which is 10 times 4 to malloc. What malloc would do is, it would go and scan the

ഒരു ഇൻറിജർ പോയിന്റർ (integer pointer) ഡാറ്റ (data) തരം ഉണ്ട്, നിങ്ങൾ ടൈപ്പ്കാസ്റ്റ് (typecast) ചെയ്തുകഴിഞ്ഞാൽ,

memory that is there, find out if there is unused space. If there is a contiguous chunk

വലതുവശത്ത് ഒരു ഇൻറിജർ പോയിന്റർ (interger pointer) ഡാറ്റ തരമാണ്, ഇവ രണ്ടും പൊരുത്തപ്പെടുന്നു.

of unused space of 40 bytes, it will claim that as a space that you want now and return

അതിനാൽ, നിങ്ങൾക്ക് ഇതിന്റെ മൂല്യം ഇടതുവശത്തേക്ക് പകർത്താനാകും. ഇപ്പോൾ ഞങ്ങൾ 40 ബൈറ്റുകൾ എങ്ങനെ ചോദിക്കും? 40 ബൈറ്റുകൾ വ്യക്തമായി

it to you. So, if I have a huge array if I have a huge memory, its possible that some

ആവശ്യപ്പെട്ടിട്ടില്ല, ബൈറ്റുകളുടെ (byte) എണ്ണം വ്യക്തമാക്കുന്നതിനുപകരം, ഓരോ ഘടകത്തിന്റെയും വലുപ്പത്തിലേക്ക് നിങ്ങൾ ആഗ്രഹിക്കുന്ന ഘടകങ്ങളുടെ എണ്ണം നിങ്ങൾ പറയുന്നു.

portions of the memory are already taken and some portions are not.

ഈ സാഹചര്യത്തിൽ, num_items എന്നത് നമുക്ക് ആവശ്യമുള്ള ഇനങ്ങളുടെ എണ്ണമാണ്, നമുക്ക് എന്താണ് വേണ്ടത്, നമുക്ക് ധാരാളം സംഖ്യകൾ

When malloc is called, lets say I called it with ah.. 40 bytes, I want 40 bytes to be

വേണം, sizeof C ലെ ഒരു ഓപ്പറേറ്ററാണ്, അതിലേക്ക് ഒരു വേരിയബിൾ (variable) പാസ് (pass) ചെയ്താൽ, അത് ആവശ്യമായ ബൈറ്റുകളുടെ

allocated it will go and look at the first free space and ask, is there 40 bytes in this

(byte) എണ്ണം നൽകും. ഞങ്ങൾ ഇത് മുമ്പ് കണ്ടിട്ടുണ്ട്.

space? If the answer is no, it would go and look at the next white space wherever there

Void * int * ലേക്ക് ടൈപ്പ്കാസ്റ്റ് (typecast) ചെയ്യുകയും മെമ്മറി അനുവദിക്കുന്നതിനുള്ള മാർഗമാണിത്. malloc എന്നത് stdlib- ൽ ഉള്ള ഒരു ഫംഗ്ഷനാണ് (function), അതിലേക്ക് നിങ്ങൾ

is no allocation done, is there 40 bytes there. Once, it finds out some free space with 40

ബൈറ്റുകളുടെ (byte) എണ്ണം കൈമാറുകയാണെങ്കിൽ, അത് മെമ്മറി (memory) സ്കാൻ (scan) ചെയ്യുകയും ബൈറ്റുകളുടെ

bytes which are continuous, it will return a pointer to the caller. So, in this case

(byte) ഉപയോഗിക്കാത്ത ഇടമുണ്ടോ എന്ന് കണ്ടെത്തുകയും ചെയ്യും. അത് കണ്ടെത്തിക്കഴിഞ്ഞാൽ, ഈ ലൊക്കേഷൻ (location) നിങ്ങൾക്ക്

in this line here, the caller is at this point right.

ഉപയോഗിക്കാൻ ജന്യമാണെന്ന് ഇത് പറയും, മുന്നോട്ട് പോയി അത് ഉപയോഗിക്കാം, കൂടാതെ നിങ്ങൾ ഇത്

The caller called malloc, malloc would return a pointer and what pointer does it return.

മെമ്മറിയുടെ (memory) തുടർച്ചയായ ഇടമായും സാധാരണയായി അറേകളായി (array) ഉപയോഗിക്കുന്നു. നിങ്ങൾക്ക് ഒരു അറേയിലേക്ക് (array) ഒരു പോയിന്റർ

It it actually returns what is called a void pointer. So, it returns something called a

(pointer) ലഭിക്കും. . ഈ ചെറിയ ഉദാഹരണം നോക്കാം, നമുക്ക് രണ്ട് പോയിന്ററുകൾ

void pointer which means, the data type is not important, I have given you space. And

(pointer) ഉണ്ട്, അതായത് *i, * array. i പൂർണ്ണസംഖ്യയുടെ ഒരു പോയിന്ററാണ് (pointer), അറേ (array) പൂർണ്ണസംഖ്യകളിലേക്കുള്ള

then, its up to you to take that and typecast it to a integer pointer or a ah.. character

ഒരു പോയിന്റർ (pointer) കൂടിയാണ്, i=int * malloc(sizeof(int)). ഒരു പൂർണ്ണസംഖ്യയ്ക്ക് മാത്രമാണ് ഇടം ക്ലെയിം (claim) ചെയ്യുന്നത്, ഞാൻ അത് (point) ചൂണ്ടിക്കാണിക്കാൻ

pointer and so on. So, in this case we asked for 40 int ah.. 10 integers 40 bytes, you

പോകുന്നു. i ഒരു പൂർണ്ണസംഖ്യയിലേക്കുള്ള പോയിന്ററാണ് (pointer), numitems ആശ്രയിച്ച് ഒന്നിൽ കൂടുതൽ സംഖ്യകൾ ആവശ്യപ്പെടുന്നു. നിങ്ങൾക്ക് ബൈറ്റുകളിലേക്ക് (byte) ഒരു പോയിന്റർ

will get a pointer to 40 bytes. You make that a pointer to int star so you

(pointer) ലഭിക്കുന്നു, അത് numitems പൂർണ്ണസംഖ്യകൾ ഉൾക്കൊള്ളാൻ കഴിയും, ഒപ്പം അതിലേക്ക്

you make that a data type int star, it now means ah.. you have a pointer which is an

ഒരു പോയിന്റർ (pointer) ലഭിക്കും, അത് അറേയിലേക്ക് (array) പോകുന്നു. I യും അറേയും (array) രണ്ടും

integer pointer data type. On the left side, you have an integer pointer data type and

പൂർണ്ണസംഖ്യകളിലേക്കുള്ള പോയിന്ററുകളാണ് (pointer), i ഒരു പൂർണ്ണസംഖ്യയിലേക്ക് മാത്രമാണ് പോയിന്റ് (point) ചെയ്യുന്നത്, അതേസമയം അറേ (array) ഒരു

once you typecast, the right side is also an integer pointer data type, these two are

കൂട്ടം ലൊക്കേഷനുകളിലേക്ക് പോയിന്റ് ചെയ്യുന്നു., ഈ സാഹചര്യത്തിൽ num_items ആണ് ലൊക്കേഷൻ. അറേ

matching. So, you can copy the value of this to the left side. So, now how do we ask for

(array) num_items പൂർണ്ണസംഖ്യകളിലേക്ക് (point) വിരൽ ചൂണ്ടുന്നു, *i = 3 ചെയ്യാൻ കഴിയും, അതുവഴി i പോയിന്റ് (point) ചെയ്ത മെമ്മറി ലൊക്കേഷന്റെ (memory

40 bytes? We didn't ask for 40 bytes explicitly, instead we said give me number of items into size of an integer. So, this is something which is a common theme

location) ഉള്ളടക്കങ്ങൾ 3 ലേക്ക് മാറ്റുകയും array[3]=5 ചെയ്യാനും കഴിയും. Array[3]=5 സാധുവാണ്, കാരണം num_items 4 നെക്കാൾ വലുതാണെങ്കിൽ array[3] സാധുവാണ്. അതിനാൽ,

that you will see in malloc right. Instead of actually specifying the number of bytes,

array[3] അറേയിലെ (array) മൂന്നാമത്തെ സ്ഥാനത്തേക്ക് പോയിന്റു (point) ചെയ്യും, അത് 5 ആയി മാറ്റുന്നു.

you say the number of ah.. elements that you want into size of each element. In this case,

I ഉം അറേയും (array) പരസ്പരം മാറ്റാവുന്നവയാണ്, കാരണം എനിക്ക് 1 പൂർണ്ണസംഖ്യ ഇവിടെ അനുവദിച്ചിരിക്കുന്നു, കൂടാതെ 4 പൂർണ്ണസംഖ്യകൾ അല്ലെങ്കിൽ 5 പൂർണ്ണസംഖ്യകൾ

num_items is the number of items that we want and what do we want, we want integers of so

ഇവിടെ അനുവദിച്ചിരിക്കുന്നു, i അറേയും (array) പൊരുത്തപ്പെടുന്നില്ലെന്ന് ഇതിനർത്ഥമില്ല. രണ്ടും ഇന്റിജെർ പോയിന്ററുകളാണ്

many ah.. count right. So, sizeof is ah.. is an operator in C, if you pass a variable

(integer pointer). അതിനാൽ, i അറേയും (array) പരസ്പരം മാറ്റാവുന്നവയാണ്. അറേകളെ (array) 0 മത്തെ ഘടകത്തിലേക്കുള്ള പോയിന്ററുകളായി (pointer) കണക്കാക്കാം,

to it, it will return the number of bytes required. We have already seen this before.

അറേ (array) യഥാർത്ഥത്തിൽ 0 സ്ഥാനത്തേക്ക് ചൂണ്ടിക്കാണിക്കുന്നു. എനിക്ക് ഒരു അറേയിലേക്കും

So, ah.. this void star in this case is typecast into int star and this is the way to allocate

(array) പോയിന്റു (pointer) ചെയ്യാനാകും. i അറേയിലേക്ക് (array) പോയിന്റു (point) ചെയ്യാൻ തുടങ്ങും, ഏത് അറേ

memory. So, again in summary malloc is a function which is in stdlib, if you pass the number

(arary) മുമ്പത്തേതിലേക്കാണ് വിരൽ ചൂണ്ടുന്നത്, കാലക്രമേണ ഇവ മാറ്റാനാകും. പ്രോഗ്രാമിന്റെ (program) ഗതിയിൽ i, അറേ (array) എന്നീ രണ്ട് വേരിയബിളുകളും

of bytes to it, it will go and scan the memory and find out if there is an unused space of

(variable) മാറ്റാൻ കഴിയും. malloc ഒരു സ്ഥലം കണ്ടെത്തിയാൽ, അത് പോയിന്റർ (pointer)

so many bytes. And once it finds out, it will it tells that this location is free for you

റിട്ടേൺ (return) ചെയ്യും. Malloc ഒരു സ്വതന്ത്ര ഇടവും കണ്ടെത്തിയില്ലെങ്കിലോ? നിങ്ങൾ ഒരുപാട് ഡാറ്റ (data) പ്രോസസ്സ് (process) ചെയ്യേണ്ട ഒരു പ്രോഗ്രാം

to use, go ahead and use it and you use it as a contiguous space of memory and contiguous

(program) എഴുതി, പ്രോഗ്രാമിലേക്ക് (program) കൂടുതൽ മെമ്മറി (memory) അനുവദിക്കണമെന്ന് നിങ്ങൾ ആഗ്രഹിക്കുന്നു,

space of memory is usually arrays. So, you get a pointer to an array.

നിങ്ങൾ malloc എന്ന് വിളിക്കുന്നു. മെമ്മറിയിലേക്ക് (memory) നോക്കി, കൂടുതൽ മെമ്മറി (memory) ലഭ്യമല്ലെങ്കിൽ

. So, lets look at this ah.. small example here,

എന്തുചെയ്യും. ഈ സാഹചര്യത്തിൽ, യഥാർത്ഥത്തിൽ malloc മെമ്മറിയിൽ (memory) സാധുവായ

so we have two ah.. pointers namely, star i and star array. So, i is a pointer of integer

ഒരു സ്ഥാനം നൽകില്ല, ഇത് NULL എന്ന് വിളിക്കുന്ന ഈ പ്രത്യേക കേസ് (case) നൽകുന്നു. വലിയ അക്ഷരങ്ങളിലുള്ള ഈ N U L L ഒരു പ്രത്യേക

type and array is also a pointer to integers, so in this line here, we have i equals int

ചിഹ്നമാണ്, മല്ലോക്ക് (malloc) 40 ബൈറ്റുകളോ (byte) 100 ബൈറ്റുകളോ (byte) മില്ല്യൺ ബൈറ്റുകളോ (million byte) മറ്റോ കണ്ടെത്താൻ ശ്രമിച്ചു, കൂടാതെ

star malloc of sizeof int. So, we are claiming space only for one integer and i is going

നിരവധി ബൈറ്റുകളുടെ (byte) ഇടത്തിന്റെ തുടർച്ചയായ ഭാഗം കണ്ടെത്താൻ കഴിഞ്ഞില്ലെങ്കിൽ, അത് NULL റിട്ടേൺ (return) ചെയ്യുന്നു . മാലോക്ക് (malloc) NULL മടക്കി നൽകിയിട്ടുണ്ടോ

to point to it. So, i is a pointer to an integer, whereas here we had, as for number of items

ഇല്ലയോ എന്ന് പോയി പരിശോധിക്കേണ്ടത് നിങ്ങളുടെ കടമയാണ്. ഇത് NULL മടക്കിനൽകുകയാണെങ്കിൽ, അതിനർത്ഥം മെമ്മറി അലോക്കേഷനിൽ (memory allocation) ചില പ്രശ്‌നങ്ങൾ സംഭവിച്ചു എന്നാണ്,

into sizeof int, you are asking for more than one integer depending on num items.

മെമ്മറി (memory) തീർന്നുപോയ ഉപയോക്താവിന് പുറത്തുകടക്കാൻ കഴിയും. ഈ എക്സിറ്റ് (exit) ഒരു ഫംഗ്ഷൻ കോളാണ്

You get a pointer to so many bytes which can occupy num items integers and you get a pointer

(functon call), ഇത് ഒരുതരം പിശക് സൂചിപ്പിക്കുന്നു. ചില പ്രശ്‌നങ്ങൾ സംഭവിക്കുന്ന നിമിഷം, നിങ്ങൾ പ്രോഗ്രാമിൽ (program) നിന്ന് പുറത്തുകടന്ന് പറയുക, എനിക്ക് വേണ്ടത്ര ഇടമില്ല, പ്രോഗ്രാം

to that, that goes into array. So, both i and array are pointers to integers, only that

(program) പ്രവർത്തിപ്പിക്കുന്നത് തുടരാനാവില്ല. എന്നിരുന്നാലും, NULL അല്ലായെങ്കിൽ, നിങ്ങൾ സ്ക്രീനിൽ (screen) ഒന്നും പ്രിന്റു (print) ചെയ്യില്ല, എക്സിറ്റ് (exit) എന്ന് വിളിക്കില്ല.

i is pointing only to one integer, whereas array is pointing to a series of locations

നിങ്ങൾ ചെയ്ത ചില അലോക്കേഷൻ (allocation) വിജയിക്കുന്നു, മാത്രമല്ല നിങ്ങൾക്കാവശ്യമുള്ളത് ശരിയായി ഉപയോഗിക്കാനും കഴിയും. ഓരോ തവണയും ഈ പരിശോധനയ്ക്ക്

right, in in this case num items location. So, num array sorry array is pointing to num_items

ശേഷം എനിക്ക് malloc ഉണ്ടാകില്ല, ഇത് നിങ്ങൾ ഓരോ തവണയും ചെയ്യേണ്ട കാര്യമാണ്. നിങ്ങൾ പരിശോധിക്കേണ്ടതുണ്ട്, നിങ്ങൾ ഒരു മാലോക്ക് ചെയ്യുമ്പോഴെല്ലാം, അലോക്കേറ്റ് (allocate)

integers, so you can do star i equals 3, so that will change the contents of the memory

കഴിയാത്ത എന്തെങ്കിലും ഉണ്ടാവാൻ സാധ്യതയുണ്ട്. അതിനാൽ, അത് NULL നൽകിയിട്ടുണ്ടോ ഇല്ലയോ എന്ന് നിങ്ങൾ പരിശോധിക്കേണ്ടതുണ്ട്. . മെമ്മറി (memory) അനുവദിക്കുന്നതിന്

ഇത് പര്യാപ്തമല്ല, മെമ്മറിയുടെ (memory)

location pointed to by i to 3 and you can do things like array of 3 is 5.

ഡീഅലോക്കേഷൻ (deallocation) എന്ന് വിളിക്കുന്നതിനെക്കുറിച്ചും നിങ്ങൾ ചിന്തിക്കണം. ഈ കോഡിന്റെ (code) ഒരു ഭാഗം നോക്കാം. എനിക്ക് f എന്ന ഫംഗ്ഷൻ (function)

So, array of 3 is 5 is valid, because ah.. if num_items is greater than ah.. 4, then

ഉണ്ട്, അതിൽ int y ഉം 10 ന്റെ അറേയും (array) ഉണ്ട്. ഇവ f ഫംഗ്ഷനുള്ളിലെ (function) ലോക്കൽ വേരിയബിളുകളാണ്

array of 3 is valid. So, array of 3 will point to the third location in the array and that

(local variable), അതിനാൽ എനിക്ക് ഇത് ഫംഗ്ഷനുകളിൽ (function) നിന്ന് അറിയാൻ കഴിയും, ഇവ ലോക്കൽ വേരിയബിളുകളായതിനാൽ (local variable), ഫംഗ്ഷൻ (function)

is changed to 5. i and array are interchangeable just, because I have 1 ah.. 1 integer allocated

വിളിക്കപ്പെടുമ്പോൾ മാത്രമേ അവ സജീവമാകൂ, ഓട്ടോമാറ്റിക് ആയി (automatic) അവ കിൽ (kill) ചെയ്യപ്പെടുകയും (return) ചെയ്യുകയും ചെയ്യുന്നു. ഫങ്ക്ഷൻ (function) റിട്ടേൺ

here and 4 integers or 5 integers allocated here, it doesn't mean that i and array are

(return) ചെയ്യുമ്പോൾ അവ യാന്ത്രികമായി നശിപ്പിക്കപ്പെടും. ഞങ്ങൾ ഫംഗ്ഷനുകൾ (function) കൈകാര്യം ചെയ്യുമ്പോൾ ഇതിനെക്കുറിച്ച്

incompatible. If we go back to the definition, both both are integer pointers right. So,

സംസാരിച്ചു. ലോക്കൽ വേരിയബിളുകൾ (local variable) നല്ലതാണ്, കാരണം നിങ്ങൾ ഫംഗ്ഷനെ (function) വിളിക്കുമ്പോൾ അവ സജീവമാവുകയും

i and array are interchangeable. So, arrays can be thought of as pointers to

നിങ്ങൾ ഫംഗ്ഷനിൽ (function) നിന്ന് മടങ്ങുകയും ചെയ്യുമ്പോൾ അവ നിർജ്ജീവമാകും. നിങ്ങൾ ഇവിടെ ഈ വരിയുടെ

the 0th element, we have been doing this for a long time now. Whenever I have an array,

അവസാനത്തിലേക്ക് പോകുമ്പോൾ, y എന്നത് ഒരു പൂർണ്ണസംഖ്യയാണ് ഡീലോക്കേറ്റ് (deallocate) ചെയ്തിരിക്കുന്നത്, 10 പൂർണ്ണസംഖ്യകളുടെ ഒരു നിരയായ അറേയും (array) ഡീലോക്കേറ്റ്

I I have been saying that we can abuse the notion of an array and say that its actually

(deallocate) ചെയ്യപ്പെടുന്നു. നിങ്ങൾക്ക് y- നെ പരാമർശിക്കാൻ കഴിയില്ല അല്ലെങ്കിൽ f- ന് പുറത്ത് എവിടെയും

pointed to the 0th location. So, i could also point to an array as well. So, in fact I can

വേരിയബിൾ (variable) അറേയെ (array) സൂചിപ്പിക്കാൻ കഴിയില്ല. ഇത് ഞങ്ങൾക്ക് ഇതിനകം അറിയാവുന്ന

do i equals array and i would start pointing to the array, which array was pointing to

കാര്യമാണ്. എല്ലാ ഓട്ടോമാറ്റിക് വേരിയബിളുകളും (automatic variable) സ്വപ്രേരിതമായി സൃഷ്ടിക്കുകയും സ്വപ്രേരിതമായി നശിപ്പിക്കുകയും

earlier and these things can be changed over time. Both the variables, i and array can

ചെയ്യുന്നു, അതിനാലാണ് അവയെ ഓട്ടോമാറ്റിക് വേരിയബിളുകൾ (automatic variable) എന്ന് വിളിക്കുന്നത്. അതേസമയം, നിങ്ങൾ മാലോക്ക് (malloc) ഉപയോഗിച്ച്

changed over course of the program.

എന്തെങ്കിലും വിളിക്കുകയാണെങ്കിൽ, ചൂണ്ടിക്കാണിച്ച മെമ്മറിയിലേക്കും (memory) പോയിന്റർ (pointer)

So, one thing that you have to be careful about is I said, if malloc goes and finds

ലഭിക്കുന്നു, നിങ്ങൾക്ക് കുറച്ച് മെമ്മറി (memory) വേണമെന്ന് ക്ലെയിം (claim) ചെയ്യുന്നു, നിങ്ങൾ

out a chunk of space, if that is free it will return the pointer to the chunk of space.

അത് സ്വതന്ത്രമാക്കണം. ഫ്രീ (free) എന്ന ഫംഗ്ഷൻ (function) ഉപയോഗിച്ചാണ് ഇത് ചെയ്യേണ്ടത്. അങ്ങനെ ഡീലോക്കേറ്റ് (deallocate) ചെയ്യാൻ മറന്നാൽ,

What if malloc does not find any free space? You wrote a program which is supposed to process

എനിക്ക് കുറച്ച് മെമ്മറി (memory) ക്ലെയിം (claim) ചെയ്യാമെന്നും ഇനി എനിക്ക് ഉപയോഗമില്ലെന്നും

a lot of data and you want more memory allocated to the program, you called malloc. Malloc

പറയാൻ അനുവദിക്കുന്നു, ഞാൻ അത് ഡീലോക്കേറ്റ് (deallocate) ചെയ്യണം, അതിനായി ഞാൻ free ഉപയോഗിക്കും. ഉദാഹരണത്തിന്, ഇവിടെ int *a malloc ആണ്.

ah.. went and looked at the memory and what if there was no more memory available.

എനിക്കതിന് ഒരു ഉപയോഗവുമില്ലെങ്കിൽ, ഞാൻ സ്വതന്ത്രമാക്കണം. അതിനാൽ, നിങ്ങൾ അങ്ങനെ ചെയ്യുന്നില്ലെങ്കിൽ എന്തുസംഭവിക്കുമെന്നത്, നിങ്ങൾ അനുവദിച്ച

In this case, actually malloc doesn't return a valid location in the memory, it returns

ഈ ചങ്ക് (chunk) ആരോ ക്ലെയിം (claim) ചെയ്തതുപോലെ തന്നെ തുടരാം, ആരെങ്കിലും ഒരു റിസർവേഷൻ (reservation)

this special case called NULL. We have seen this before, this N U L L in capital letters

നടത്തി, അത് ഇപ്പോഴും ഉപയോഗിക്കുന്നു, നിങ്ങൾ ഒരു ഹോട്ടലിൽ പോകുന്നത് പോലെയാണ് ഇത്, നിങ്ങൾ ഒരു റെസ്റ്റോറന്റിലേക്ക് പോകാമെന്ന് പറയാൻ

is a special symbol, it this cannot be any valid pointer right. Because, its not any

അനുവദിക്കുന്നു, നിങ്ങൾ ഒരു ഫോൺ കോൾ ചെയ്യുന്നു, നിങ്ങൾ ഒരു ടേബിൾ (table) റിസർവ്

valid pointer and malloc if it returns that you know that there is some error that happened.

ചെയ്യുന്നു. പക്ഷേ നിങ്ങൾ പോയില്ല. അപ്പോൾ, റസ്റ്റോറന്റിന് ഒരു ഘട്ടത്തിൽ അറിയേണ്ടിവരും, ആരെങ്കിലും മേശ ഉപയോഗിക്കുമോ ഇല്ലയോ എന്ന്. നിങ്ങൾ

Malloc tried to find out your 40 bytes or 100 bytes or ah.. 1 million bytes or whatever

വിളിക്കാൻ പോകുന്നില്ലെങ്കിൽ, നിങ്ങൾ പോകുന്നില്ലെങ്കിൽ വിളിച്ച് അവരോട് പറയുന്നത് നിങ്ങൾക്ക്

and if it was not able to find out contiguous chunk of space of so many bytes, it returns

നല്ലതാണ്, അല്ലെങ്കിൽ നിങ്ങൾ യഥാർത്ഥത്തിൽ റെസ്റ്റോറന്റിലേക്ക് പോയി, ഭക്ഷണം കഴിച്ചു, ആ സമയത്ത് അത് റിസർവ് ചെയ്തിട്ടില്ല. അത്

with NULL. So, its your duty to go and check, if malloc

വീണ്ടും സ്വതന്ത്രമാക്കേണ്ടതുണ്ട്. നിങ്ങൾ കുറച്ച് സ്ഥലം ക്ലെയിം (claim) ചെയ്യുമ്പോഴെല്ലാം, തിരികെ പോയി അത്

returned NULL or not. If it returned NULL, it means some problem happened in memory allocation,

വീണ്ടെടുക്കാൻ സിസ്റ്റത്തോട് (system) പറയേണ്ടത് നിങ്ങളുടെ കടമയാണ്. നിങ്ങൾക്ക് ഇത് ഇനി ആവശ്യമില്ല.

you can print ah.. to the ah.. user that you actually ran out of the ah.. memory and you

നിങ്ങൾ ഇത് സ്വതന്ത്രമാക്കിയ കഴിഞ്ഞാൽ, ഈ ലൈനിന് (line) താഴെ ഇനി ഉപയോഗിക്കാൻ കഴിയില്ല. ഞാൻ സ്വതന്ത്രമാക്കിയുകഴിഞ്ഞാൽ,

can do exit. So, this exit of one is again a function call, which indicates some kind

എനിക്ക് ഇനി സ്ഥലം കരുതിവച്ചിട്ടില്ല, ഒരു കാര്യത്തിലേക്കും വിരൽ ചൂണ്ടുന്നില്ല.

of an error. So, the moment some problem happens, you may want to exit from the program and

a[i]=5 ന് തുല്യമാണെന്ന് എനിക്ക് പറയാനാവില്ല, ഒന്നുകിൽ ഞാൻ പോയി പുതിയ അലോക്കേഷൻ

say, I didn't have enough space, I couldn't have continued running the program.

(allocation) നടത്തണം അല്ലെങ്കിൽ ഇതിനകം അനുവദിച്ച എന്തെങ്കിലും ഞാൻ ചൂണ്ടിക്കാണിക്കണം.

But however if a is not NULL, you will not print anything on the screen, you will not

int b [10] ആയി പ്രഖ്യാപിക്കുകയോ അല്ലെങ്കിൽ ഇവിടെ നൽകിയിരിക്കുന്നതുപോലെ എനിക്ക് പുതിയ അലോക്കേഷൻ (allocation) നടത്തുകയോ ചെയ്താൽ a=b പോലുള്ള എന്തെങ്കിലും

call exit. So, a is successful successfully pointing to some allocation that you did and

ചെയ്യാൻ കഴിയും. വീണ്ടും നിയുക്തമാക്കുകയോ വീണ്ടും അനുവദിക്കുകയോ ചെയ്തില്ലെങ്കിൽ നിങ്ങൾ ഒരു സ്വതന്ത്ര പോയിന്റർ (pointer) ഉപയോഗിക്കരുത്.

you can use the a you want it right. So, this is something that you have to keep in mind.

പ്രോഗ്രാം അവസാനിക്കുമ്പോൾ malloc അനുവദിച്ച ഇടം

Even though, I am not going to show this thing in all the subsequent code. So, I will not

സ്വതന്ത്രമാകും. നിങ്ങൾ എപ്പോഴെങ്കിലും മെമ്മറി (memory) ശൂന്യമാക്കിയില്ലെങ്കിൽ, നിങ്ങൾ കുറച്ച് മെമ്മറി

have malloc followed by this check every time, it is something that you have to do every

(memory) അനുവദിക്കുന്നതിനാൽ നിങ്ങൾ അത് ഉപയോഗിക്കുന്നു. എന്നാൽ നിങ്ങൾ free ചെയ്യരുത് എന്ന്

time. You have to go and check, whenever you do a malloc, its possible that there is something

പറയുകയും അത് തുടരുകയും ചെയ്യുന്നു. പതുക്കെ പതുക്കെ നിങ്ങളുടെ മെമ്മറി (memory) ഉപയോഗിക്കും, ചില സമയങ്ങളിൽ നിങ്ങളുടെ മെമ്മറി (memory) പൂർണ്ണമായിത്തീരും.

that malloc can not allocate. Therefore, you have to check whether it returned NULL or

ഈ സന്ദർഭങ്ങളിൽ നിങ്ങൾ വ്യക്തമായ മെമ്മറി ഡീലോക്കേഷൻ (memory deallocation) ചെയ്തില്ലെങ്കിൽ,

not.

പ്രോഗ്രാം (program) പുറത്തുകടക്കുമ്പോൾ, നിങ്ങളുടെ പ്രോഗ്രാം

. Its not its also not enough to just allocate

(program) അതിന്റെ പ്രവൃത്തികളോടെയാണ് ചെയ്യുന്നത്, നിങ്ങൾക്ക്

memory, you also have to think about what is called deallocation of memory. So, lets

ഇനി ഈ ഇടം ക്ലെയിം (claim) ചെയ്യേണ്ടതില്ല. യാന്ത്രികമായി, എല്ലാം നിങ്ങളുടെ ഓപ്പറേറ്റിംഗ്

go and look at this piece of code here. I have a function f which has int y and array

സിസ്റ്റം (operating system) ശരിയാക്കുന്നു. നിങ്ങളുടെ പ്രോഗ്രാം (program) ക്ലെയിം (claim) ചെയ്യുന്ന എല്ലാ

of 10. These are local variables within the function f and I could so I know this from

മെമ്മറിയും (memory) അവസാനിപ്പിക്കാനും നിങ്ങളുടെ പ്രോഗ്രാം (program) അവസാനിപ്പിക്കാനും നിങ്ങൾക്ക് കാത്തിരിക്കാം. പക്ഷേ അത് നല്ല പരിശീലനമല്ല. നിങ്ങളുടെ പ്രോഗ്രാമിന്

functions that since these are local variables, they become alive only when the function is

(program) മെമ്മറി (memory) ആവശ്യമില്ലാത്തപ്പോൾ തന്നെ അത് ഡീലോക്കേറ്റ് (deallocate) ചെയ്യുക എന്നതാണ് നല്ല പരിശീലനം, കാരണം

called and they are automatically killed and returned. When the function returns, they

പിന്നീട് കുറച്ച് പ്രവൃത്തികൾ ചെയ്യുന്നതിന് നിങ്ങളുടെ സ്വന്തം പ്രോഗ്രാമിന് (program) കൂടുതൽ മെമ്മറി (memory) ആവശ്യമായി വന്നേക്കാം.

are automatically destroyed. So, we talked about this, when we dealt with functions.

. create_date എന്ന ഒരു ചെറിയ ഫംഗ്ഷൻ (function) നോക്കാം. മാസം, ദിവസം, വർഷം

So, local variables are good, because when you call the function they become alive and

എന്നിങ്ങനെ മൂന്ന് സംഖ്യകൾ എടുക്കാൻ പോകുന്നു, ഒരു തീയതി തിരികെ നൽകണം. ഞാൻ

when you return from the function, they become dead. So, when you go to the end of this line

ഇത് ചെയ്തുവെന്ന് പറയട്ടെ, തീയതി നക്ഷത്രം d. തീയതി എന്നത് ഒരു പോയിന്ററാണ് (pointer),

f here, y which is an integer is deallocated, array which is an array of 10 integers is

അത് മെമ്മറി (memory) അനുവദിക്കുന്നില്ല മാസം, ദിവസം, വർഷം എന്നിവയ്ക്ക് മൂന്ന് കാര്യങ്ങൾ. തീയതി ടൈപ്പുചെയ്യുന്നതിനുള്ള ഒരു പോയിന്റർ (pointer)

also deallocated. You can't refer to y or you can't refer to array, the variable array

മാത്രമേ ഇത് പ്രഖ്യാപിക്കൂ. നിങ്ങൾക്ക് ഒരു പോയിന്ററിനായി (pointer) ഇടമുണ്ട്, എന്നാൽ യഥാർത്ഥ അംഗങ്ങളെ

anywhere outside f. This is something that we know already. So, all automatic variables

ഇതുവരെ അനുവദിച്ചിട്ടില്ല, d ന്റെ മാസം, നിങ്ങൾ പാസ് (pass) ചെയ്ത മാസമായിരിക്കണം, d ന്റെ ദിവസം നിങ്ങൾ

are created automatically and destroyed automatically, thats why they are called automatic variables.

പാസ് (pass) ചെയ്ത ദിവസവും d യുടെ വർഷവും ആയിരിക്കണം,

Whereas, if you do ah.. call something with malloc, you are getting a pointer to the memory

നിങ്ങൾ കടന്നുപോയ (pass) വർഷവും പോയിന്റർ (pointer) മടക്കിനൽകുന്നതുമായ d ആയിരിക്കണം, ഇത്

that was pointed to and its your duty now, you claim the memory you wanted some memory

തെറ്റായിരിക്കും, കാരണം d യ്ക്ക് ഒരു മെമ്മറി (memory) അവകാശവും അനുവദിച്ചിട്ടില്ല. അതിനുള്ള ശരിയായ മാർഗം ഇനിപ്പറയുന്നതാണ്. d ഒരു പോയിന്ററാണ് (pointer), ആദ്യം സ്ഥലം

and you have to free it out. So, it has to be done using this function called free and

അനുവദിക്കുക, നിങ്ങൾക്ക് എത്ര സ്ഥലം അനുവദിക്കണം? ഒരു തീയതി തരത്തിന് സ്ഥലം അനുവദിക്കാൻ ഞാൻ ആഗ്രഹിക്കുന്നു, തീയതി തരത്തിന് എന്താണ്

ah.. forgetting to deallocate so, lets say I claim some memory and I don't have use for

ഉള്ളത്? ഇതിന് ഒരു മാസത്തെ ഫീൽഡ് (field), ഒരു ദിവസത്തെ ഫീൽഡ് (field), ഒരു വർഷത്തെ ഫീൽഡ്

it anymore, I have to deallocate it and ah.. for that I will use free. So, for example

(field) എന്നിവയുണ്ട്, ഞങ്ങൾക്ക് മൂന്ന് കാര്യങ്ങൾ ആവശ്യമാണ്. sizeof(date) , sizeof(month), sizeof(year)

here int star a is malloc, so many by so many bytes ah.. as num item integers ah.. demands

പൂർണ്ണസംഖ്യകളാണ്, ഒന്ന് മാസത്തിന്, ഒന്ന് ദിവസത്തിന്, വർഷത്തിൽ ഒന്ന്. D- ന് നിയുക്തമാക്കിയിരിക്കുന്ന ഒരു പോയിന്റർ (pointer) നൽകുന്ന തീയതിയിലെ വലുപ്പത്തിന്റെ

മാലോക്ക് (malloc) നിങ്ങൾ ചെയ്യുമ്പോൾ. ഇപ്പോൾ

and I used that. If I don't have any use for it, I should go

d യഥാർത്ഥത്തിൽ ഒരു അനുവദിച്ച സ്ഥലത്തേക്കാണ്

and free up a right. So, if you don't if you don't do that what might happen is that this

പോയിന്റ് (point) ചെയ്യുന്നത്. അനുവദിച്ച സ്ഥലത്തേക്ക് പോയിന്റു (point) ചെയ്‌തുകഴിഞ്ഞാൽ, d->month, d->year, d->day എന്നിവ ചെയ്യുന്നത് ശരിയാണ്. നിങ്ങൾ d റിട്ടേൺ

chunk that you allocated may remain as oh somebody claimed it and somebody made a reservation

(return) ചെയ്യുമ്പോൾ മടങ്ങുമ്പോൾ, നിങ്ങൾ യഥാർത്ഥത്തിൽ റിസർവ് (reserve) ചെയ്ത സ്ഥലത്തേക്ക്

and its still being used, thats how the complier would treat it. So, this is like you go to

ഒരു പോയിന്റർ (pointer) നൽകുന്നു. റിസർവ് (reserve) ചെയ്ത ഇടം ഇപ്പോഴും നിലവിലുണ്ട്, നിങ്ങൾ

a hotel, ah.. ah.. lets say you go to a restaurant you make a phone call and you reserve a table

റിസർവ് (reserve) ചെയ്ത സ്ഥലത്തേക്ക് ഒരു പോയിന്റർ (pointer) നൽകുന്നു. വലതുവശത്തുള്ള പ്രവർത്തനം

right. You reserved the table, but you never turned up.

ശരിയാണ്, അതേസമയം ഇടതുവശത്തുള്ള പ്രവർത്തനം ശരിയല്ല. കാരണം, നിങ്ങൾ ഇടതുവശത്ത് സ്ഥലം

Then, the restaurant would have to know at some point, whether somebody is going to turn

അനുവദിച്ചിട്ടില്ല, നിങ്ങൾ വ്യക്തമായി വലതുവശത്ത് സ്ഥലം അനുവദിച്ചു. അതിനാൽ, നമ്മൾ ചെയ്യേണ്ടത് ഒരു കാര്യമാണ് .. സ്ഥലം

up and use the table or not right. And if you are not going to call, ah.. if you are

വ്യക്തമായി അനുവദിച്ചിട്ടുണ്ടെങ്കിലും, അത് ശരിയായി ഡീലോക്കേറ്റ് (deallocate) ചെയ്യുന്നതിന് create_date ഉത്തരവാദിയല്ലെന്ന്

not going to ah.. go to the restaurant, its good for you to call the restaurant and tell

ഓർക്കുക. നിങ്ങൾ ഇത് ഇതുവരെ വ്യക്തമായി ഡീലോക്കേറ്റ് (deallocate) ചെയ്തിട്ടില്ല. നിങ്ങൾ

them, I I even though I called, I made a reservation, I don't want it any more. So, that is equivalent

ഇത് വ്യക്തമായി അനുവദിച്ചു. പിന്നീട് വന്ന് ഡീലോക്കേറ്റ് (deallocate) ചെയ്യേണ്ടത് ആരുടെയെങ്കിലും ജോലിയാണ്, ഇത് ആരാണെന്ന് പിന്നീട് ഞങ്ങൾ കാണും.

to free or you actually went to the restaurant, you had your meal you return back, at that

. ഇവിടെ ഒരു ചെറിയ കാര്യം കാണാം. Date *today, today =create_date(9, 1, 2005) ആണ്,

point its not reserved anymore. So, you have to say that OK this table is not reserved

റിട്ടേൺ (return) ചെയ്യുക. 2005 ജനുവരി 9 എന്ന്

any more, it has to be freed again. So, this is the equivalent ah.. or analogy

പറയാൻ അനുവദിക്കുക. ഞാൻ ഇന്ന് ഒരു വേരിയബിൾ

that I can give you for malloc and free. Whenever you claim some space, its your duty to go

(variable) സൃഷ്ടിച്ചു. Today തീയതി എന്ന് വിളിക്കുന്ന ഡാറ്റാ (data) തരത്തിലേക്കുള്ള ഒരു പോയിന്ററാണ് (pointer), create_date, date എന്ന് വിളിക്കുന്ന ഡാറ്റാ

back and tell the system to reclaim it. You don't need the ah.. you don't need this anymore.

(data) തരത്തിലേക്ക് ഒരു പോയിന്റർ (pointer) നൽകുന്നു. ഞാൻ today ഉപയോഗിച്ചു, തുടർന്ന്

So, once you free it, you cannot use a anymore below this line. So, once I have freed a I

ഞാൻ അത് റിട്ടേൺ (return) ചെയ്തു. ഈ സമയത്ത് create_date കുറച്ച് മെമ്മറി (memory) അനുവദിച്ചു, അത് നിങ്ങൾക്ക് ഇന്ന് ലഭിച്ചു. കാര്യങ്ങളുടെ

don't have space reserved for a anymore, a is not pointing to anything. Therefore, I

ക്രമം ശരിയായി നോക്കാം. foo എന്ന് വിളിക്കുന്ന ഈ ഫംഗ്ഷനുള്ളിൽ, today ഒരു ലോക്കൽ വേരിയബിളാണ്

cannot say a of i equals 5 and so on, i cannot do that.

(local variable) പോയിന്റർ. ഇത് Date (datatype) ലേക്ക്

I should either go and do new allocation or I should make a point to something that is

പോയിന്റുചെയ്യേണ്ടതുണ്ട്. create_date എന്ന് വിളിക്കുമ്പോൾ, create_date- നുള്ളിൽ നിങ്ങൾ തീയതിക്ക് ഒന്ന്, മാസത്തിന് ഒന്ന്, വർഷത്തിൽ ഒന്ന് എന്നിവയ്ക്ക്

already allocated. So, I could do something like a equals b, if b was declared as int

സ്ഥലം അനുവദിച്ചു, ഇതിലേക്ക് പോയിന്റർ (pointer) നൽകുന്നു. അതിനാൽ, ഈ സമയത്ത് നിങ്ങളുടെ

b of 10 or I could do new allocation as it was given here. So, you must not use a freed

today ഫീൽഡ് (field) സ്ട്രക്ച്ചറിന് (structure) നിങ്ങൾ നൽകിയ സ്ഥാനത്തേക്ക് വിരൽ ചൂണ്ടുന്നു. today ഞങ്ങൾ ഉപയോഗിച്ചു, റിട്ടേൺ (return) ചെയ്തു, അതിന്റെ

pointer, unless it is re assigned or reallocated. So, keep this in mind.

അവസാനത്തിലെത്തി. ഈ ഘട്ടത്തിൽ ഞങ്ങൾ foo വിൽ നിന്ന് മടങ്ങുന്നു, ഇപ്പോൾ എന്ത് സംഭവിക്കും?

So, space allocated by malloc is freed when the program terminates. So, if you don't free up memory ever, so you use so you allocate some memory, you use it. But lets say you

ഇന്ന്, foo- നുള്ളിൽ ഒരു ലോക്കൽ വേരിയബിൾ (local variable) ആയതിനാൽ, ഇന്ന് നശിപ്പിക്കപ്പെടുന്നു. foo ആർക്കും today ആക്‌സസ് (access) ചെയ്യാൻ കഴിയില്ല, കാരണം today foo- നുള്ള ഒരു ലോക്കൽ വേരിയബിൾ

(local variable) ആണ്. Today നഷ്‌ടമായതിനാൽ‌, നിങ്ങൾ‌ക്ക് ഉണ്ടായിരുന്ന

don't do free and you keep doing that. So, slowly and steadily your memory will get used

റിസർ‌വ്വ് സ്ഥലത്തേക്ക് ഒരു പോയിന്ററും (pointer) നഷ്‌ടപ്പെട്ടു. ഒരു സ്ട്രക്ച്ചറിന് (structure) നിങ്ങൾ സ്ഥലം നീക്കിവച്ചിട്ടുണ്ട്,

up, at some point of time your memory might become full right. So, in any of these cases

എന്നാൽ സ്ട്രക്ച്ചറിലേക്ക് (structure) പോയിന്റ് ചെയ്തിരുന്ന today നശിപ്പിക്കപ്പെട്ടു. നിങ്ങൾ അനുവദിച്ച മെമ്മറിയിലേക്ക് (memory) മടങ്ങാനുള്ള പാത നിങ്ങൾക്ക് നഷ്‌ടപ്പെട്ടു, ഇതാണ് പ്രശ്‌നം.

right if you don't do explicit memory deallocation, when the program exits, your program is done

നിങ്ങൾക്ക് ഒരു ഫംഗ്ഷനിൽ (function) നിന്ന് അനുവദിച്ച എന്തെങ്കിലും ഉണ്ടെങ്കിൽ, അത് ലോക്കൽ വേരിയബിളിൽ

with its work, you don't need to claim this space anymore. Automatically, everything gets

(local variable) ഇടുകയും അത് വ്യക്തമായി ഡീലോക്കേറ്റ് (deallocate) ചെയ്തില്ലെങ്കിൽ, ആ കാര്യം ഇപ്പോഴും

deallocated by your operating system right. So, you can wait for your program to terminate

ഒളിഞ്ഞിരിക്കും. നിങ്ങൾ‌ക്ക് ഉണ്ടായിരുന്ന ഈ ഘടന ഇപ്പോഴും മറഞ്ഞിരിക്കുന്നു, നിങ്ങൾക്ക് ഇത് സ്വതന്ത്രമാക്കാൻ ഒരു മാർഗവുമില്ല, പ്രോഗ്രാം (program) പൂർത്തിയാകുമ്പോൾ

and free up all memory that you that your program claim. So, some people do that, but

മാത്രമേ ഇത് സ്വതന്ത്രമാകൂ. അതിനാൽ, നാം അതിനെക്കുറിച്ച് ശ്രദ്ധാലുവായിരിക്കണം. സാധ്യമായ വിവിധ പരിഹാരങ്ങളുണ്ട്, ഞാൻ create_date ചെയ്തുവെന്ന്

thats not good practice. So, the good practice is as and when when your program does not

പറയാം. തീയതിയിൽ ഞാൻ ചെയ്യേണ്ടതെന്തും ചെയ്തു, എനിക്ക് ഇനി തീയതി ആവശ്യമില്ലെന്ന്

need some memory as well deallocate it, because your own program may need more memory for

എനിക്കറിയാം, കൂടാതെ ഞാൻ ഫംഗ്ഷനിൽ (function) നിന്ന് മടങ്ങിവരുന്നു, today free ആണ്. ഫംഗ്ഷൻ (function)

doing some more work later.

പോയി അതിനായി നീക്കിവച്ചിരിക്കുന്ന അല്ലെങ്കിൽ റിസർവ്

. So, lets look at a small function called create_date.

(reserve) ചെയ്ത സ്ഥലം നോക്കുകയും റിസർവേഷൻ

Its going to take three integers month, day and year and its supposed to return a date

(reservation) നീക്കം ചെയ്യുകയും ചെയ്യും. അതിനാൽ, ആ ഇടം പ്രോഗ്രാമിന് (program) ഉപയോഗിക്കാൻ കഴിയും, നിങ്ങൾ അത് തിരികെ നൽകുമ്പോൾ,

right. So, lets say I did this, Date star d. So, d is a pointer of the type Date and

നിങ്ങൾ ചെയ്ത എല്ലാ അലോക്കേഷനും (allocation) നിങ്ങൾ ഇതിനകം തന്നെ ശ്രദ്ധിച്ചിട്ടുണ്ട്, നിങ്ങളുടെ റിസർവേഷൻ നീക്കംചെയ്തു. ഇപ്പോൾ ഞാൻ കാണിക്കാൻ പോകുന്നത് ഇടതുവശത്തുള്ള

remember, it doesn't allocate memory to it doesn't allocate ah.. three things for month,

പ്രവർത്തനം നോക്കാം. അതിനാൽ, int *f, f എന്നത് ഒരു ഫംഗ്ഷനും (function) i ഫംഗ്ഷനുള്ളിലെ

day and year right. It only declares a pointer to type Date. So, you have space for a pointer,

(function) ഒരു ലോക്കൽ വേരിയബിളാണ് (local variable), കൂടാതെ നിങ്ങൾ ലോക്കൽ വേരിയബിളിലേക്ക് (local variable) (address) നൽകുന്നു.

but the actual members are not allocated yet and lets say you did this.

ഈ int * എന്താണ് ചെയ്യുന്നത്. ഒരു പൂർണ്ണസംഖ്യയിലേക്ക് പോയിന്റർ (pointer) നൽകുന്നുവെന്നാണ്. ഇത് നിങ്ങൾക്ക് ചെയ്യാൻ

d's month, is supposed to be the month that you passed on, d's day is supposed to be the day that you passed on and d's year, is supposed to be the year that you passed on and return

കഴിയുന്ന ഒന്നാണോ? ഇത് സാധ്യമല്ല, കാരണം ഫംഗ്ഷൻ (funcion) തിരികെ ലഭിക്കുമ്പോൾ i ഒരു ലോക്കൽ വേരിയബിൾ (local variable) ആണ്, i നശിപ്പിക്കപ്പെടുന്നു,

the pointer d, lets say we did this right. So, this would be a this would be wrong, because

ഇനി മുതൽ i വിലാസം ട്രാക്കു (track) ചെയ്യുന്നത് ശരിയല്ല. നിങ്ങൾക്ക് ഇത് ഇനി ട്രാക്കു

d is not allocated any memory right. So, the correct way to do that is as follows. d is

(track) ചെയ്യാൻ കഴിയില്ല. വലതുവശത്തുള്ള ഈ ഫംഗ്ഷനെ (function) നോക്കാം, ഇത് ഒരു int * തിരികെ നൽകണം, അത് ഒരു പൂർണ്ണസംഖ്യയിലേക്ക് ഒരു പോയിന്റർ (pointer)

a pointer, first allocate space and how much space do you want to allocate?

നൽകുന്നു. ഇവിടെ നിങ്ങൾക്ക് ഒരു ലോക്കൽ വേരിയബിൾ (local variable) അറേ (array) ഉണ്ട്, അത്

I want to allocate space for one Date type and what does the Date type have? It has one

10 പൂർണ്ണസംഖ്യകളുടെ ഒരു ശ്രേണിയാണ്, നിങ്ങൾ അറേ (array) നൽകുന്നു, അതിനർത്ഥം, നിങ്ങൾ അറേയുടെ (array) 0 മത്തെ ഘടകത്തിന്റെ സ്ഥാനം

month field, one day field and one year field, right we need three things. So, when you see

നൽകുന്നു. എന്നാൽ വീണ്ടും നിങ്ങൾ ഈ റിട്ടേൺ (return) അറേ (array) ഒരു പോയിന്റർ

sizeof Date, sizeof Date is three integers, one for month, one for day and one for year.

(pointer) 0-ാം സ്ഥാനത്തേക്ക് മടങ്ങുക. Make_array- ന് അറേ (array) (local) പ്രാദേശികമായതിനാൽ, നിങ്ങൾ make_array- ൽ നിന്ന്

And when you do malloc of sizeof Date that returns a pointer that is assigned to d. So,

മടങ്ങുമ്പോൾ അറേ (array) നശിപ്പിക്കപ്പെടും. നിങ്ങളുടേതാണെന്ന് അവകാശപ്പെടാൻ കഴിയാത്ത ഒരു സ്ഥലത്തേക്ക് യഥാർത്ഥത്തിൽ പോയിന്റു (point) ചെയ്യുന്ന ഒരു പോയിന്റർ (pointer) നിങ്ങൾക്കുണ്ട്.

now d is actually pointing to an allocated space. Once its pointing to an allocated space,

ഇതൊരു പ്രശ്‌നമാണ്, നിങ്ങൾ ഇത് ചെയ്യുകയാണെങ്കിൽ, ചിലപ്പോൾ ഇത് മുഴുവൻ പ്രവർത്തിക്കുന്നതായി തോന്നും. ഇത് പ്രവർത്തിച്ചേക്കാം, കാരണം നിങ്ങൾ ഈ make_array-

its ok to do d arrow month, d arrow day and d arrow year.

ൽ നിന്ന് മടങ്ങിയെത്തുമ്പോൾ, സ്ഥലത്ത് ഇപ്പോഴും എല്ലാ മൂല്യങ്ങളും അടങ്ങിയിരിക്കാം, ആരും അത് വീണ്ടെടുത്തില്ല. നിങ്ങൾ ആ സ്ഥാനത്തേക്ക്

And when you return d, you are actually returning a pointer to the reserved space. So, the reserved

തിരികെ പോകുമ്പോൾ, നിങ്ങൾ ഇപ്പോഴും മൂല്യങ്ങൾ കാണുന്നു. നിങ്ങൾ‌ക്ക് ആവശ്യമില്ലാത്ത ഈ മെമ്മറി (memory) സ്ഥാനം മറ്റെവിടെയെങ്കിലും

space still exist and you are returning a pointer to the reserved space. So, the function

ഉപയോഗിച്ചു, ഇപ്പോൾ‌ നിങ്ങൾ‌ യഥാർത്ഥത്തിൽ ആക്‌സസ്സു (access) ചെയ്യുന്നു. സ്ഥലം വീണ്ടും അനുവദിച്ചാൽ ഇത് പ്രവചനാതീതമായിത്തീരും, പക്ഷേ സ്ഥലം മറ്റാർക്കും

on the right side is correct, whereas the function on the left side is not. Because,

പുനർവിന്യസിച്ചിട്ടില്ലെങ്കിൽ, അത് പ്രവർത്തിച്ചേക്കാം. പൊതുവേ, അനുവദിക്കാത്ത സ്ഥലത്തെ നിങ്ങൾ ആശ്രയിക്കരുത്.

you didn't allocate space on the left side, you explicitly allocated space on the right

നിങ്ങൾ‌ക്ക് ലോക്കൽ‌ വേരിയബിളുകളിലേക്കോ (local variable) അല്ലെങ്കിൽ‌ നിങ്ങൾ‌ അകത്ത് വകയിരുത്തുന്നതിലേക്കോ പോയിൻററുകൾ‌ (pointer) നൽ‌കുകയാണെങ്കിൽ‌,

side. So, one thing we have to do is ah.. even though the space is explicitly allocated,

ആദ്യം ഡൈനാമിക് അലോക്കേഷൻ‌ (dynamic allocation) നടത്തുകയും നിങ്ങൾ‌ ഒരു പോയിന്ററിലൂടെ (pointer) കടന്നുപോകുകയും ചെയ്യുന്നു. അതുപോലെ, ഇവിടെ നിങ്ങൾ ഡൈനാമിക്

remember create_date is not responsible for deallocating it right. You are not explicitly

അലോക്കേഷൻ (dynamic allocation) ചെയ്തു, ഫംഗ്ഷൻ (function) മടങ്ങിയെത്തുമ്പോൾ ഈ 10 സംഖ്യകൾ ഡീലോക്കേറ്റ്

deallocating it yet. You have only explicitly allocated it. Its somebody’s job to come

(deallocate) ചെയ്യാൻ പോകുന്നില്ല, അതിനാലാണ് അതിലേക്ക് ഒരു പോയിന്റർ (pointer) മടക്കിനൽകുന്നത്. നിങ്ങൾ malloc ഉപയോഗിച്ച് അനുവദിക്കുകയും

and deallocate it later, we will see who is this somebody must be later.

പോയിന്റർ (pointer) തിരികെ നൽകുകയും ചെയ്യുന്നു,

. Lets see a small thing here right. So, Date

ഇത് അനുവദനീയമാണ്. മൾട്ടി-ഡൈമെൻഷണൽ അറേകൾ (multidimensional array) എങ്ങനെ

star today, today is create_date 9, 1, 2005 and do return. So, I want to do lets say 9th

അനുവദിക്കാമെന്ന് നോക്കാം. സിംഗിൾ ഡൈമെൻഷണൽ അറേകൾ (single dimensional array) അല്ലെങ്കിൽ പൂർണ്ണസംഖ്യകളുടെ ഒരു ശ്രേണി, പ്രതീകങ്ങളുടെ നിര തുടങ്ങിയവയ്‌ക്കായി ഞങ്ങൾ തിരയുന്നത്

of January 2005. I created a variable called today. So, today is a pointer to the data

മാത്രമല്ല. പലതവണ നിങ്ങൾ മെട്രിക്സ് (matrix) അല്ലെങ്കിൽ 3D . മെട്രിക്സുകൾ (matrix) നിർമ്മിക്കാൻ ആഗ്രഹിക്കുന്നു, ഇത് എങ്ങനെ ചെയ്യും.

type called Date, create_date in turn returns a pointer to data type called Date. I used today and then I returned it. So, at this point create_date allocated some memory and

ആരംഭിക്കുന്നത് int **p. p എന്നതിന്റെ

you got that in today. So, lets look at the sequence of things right. So, inside this function called foo right, so today is a local variable and what is today,

അർത്ഥം ഒരു പൂർണ്ണസംഖ്യയിലേക്കുള്ള പോയിന്ററാണ് (pointer).

its actually a pointer. Its supposed to point to ah.. point to a Date data type. And when you call create_date, so inside create_date you allocated space one for date, one for

എന്താണ് അർത്ഥമാക്കുന്നത് എന്ന് നോക്കാം. p ഒരു

month and one for year, you allocated space for the structure, you return the pointer

പൂർണ്ണസംഖ്യയിലേക്കല്ല, p മറ്റൊരു പോയിന്ററിലേക്ക്

to this. So, at this point your today field is pointing to the location that you gave for the structure. And lets say, we used today and we returned, we came to the end of it.

(pointer) പോയിന്റ് (point) ചെയ്യുന്നു. അത് ചില സംഖ്യകളിലേക്ക് പോയിന്റ് (point) ചെയ്യുന്നു.

And this point we return from foo, what would happen now? Since, today is a local variable

P മറ്റൊരു പോയിന്ററിലേക്ക് (pointer) വിരൽ ചൂണ്ടുന്നു, അത് ഒരു പൂർണ്ണസംഖ്യയിലേക്ക് വിരൽ ചൂണ്ടുന്നു.

within foo, today gets destroyed. Its an automatic variable right, the automatic variable gets destroyed. So, whoever called foo cannot access today, because today is a local variable within foo. And because today is lost, you also lost a pointer to some reserved space that you had. You reserved space for a structure, but today which was holding the pointer to the

ശരി. Int എന്നത് അങ്ങനെ തന്നെ, int i ഒരു പൂർണ്ണസംഖ്യയ്‌ക്ക് ഞാൻ ശരിയായ ഇടം പ്രഖ്യാപിക്കുന്നു. ഇപ്പോൾ, ഒരു മൾട്ടി-ഡൈമൻഷണൽ

structure was destroyed. Therefore, you lost the trail to go back to

അറേ (multidiemnsional array) എങ്ങനെ അനുവദിക്കാമെന്ന്

the memory that you allocated, so this is the problem. So, whenever you have something

നോക്കാം. അതിന്‌ൽ, നിങ്ങൾ ആദ്യം ചെയ്യുന്നത്

that is allocated from a function and if you put that in the local variable and if you

എനിക്ക് M വരികളും N നിരകളും വേണമെന്ന് പറയാൻ അനുവദിക്കുന്നു. അതിനാൽ, നിങ്ങൾ ആദ്യം

didn't explicitly deallocate it, that thing is still going to lurk around. This ah.. structure

ചെയ്യുന്നത് ആദ്യം m എം പോയിന്ററുകൾ (pointer) അനുവദിക്കുക എന്നതാണ്. ഞങ്ങൾക്ക്

that you had is still going to lurk around and you will have no way to free it, this

അനുവദിച്ചിരിക്കുന്ന M പോയിന്ററുകൾ (pointer)

will get freed only when the program gets ah.. done. So, we have to be careful about it. So, there are various possible solutions and the cleanest solution is, lets say, I did create_date. I did whatever I want to do with Date, I know that I don't need date anymore

ഉണ്ട്, തുടർന്ന് ഓരോ പോയിന്റർ വേരിയബിളും (pointer variable), നിങ്ങൾ ഇപ്പോൾ N സംഖ്യകളുടെ ഒരു വിഹിതം നൽകുന്നു. പൂർണ്ണസംഖ്യകൾക്ക് M പോയിന്ററുകൾ (pointer) അനുവദിക്കുകയും

തുടർന്ന്, നിങ്ങൾ ഒരു സമയം N സംഖ്യകൾ

and I am returning from the function as well free today. So, that the so when you say free

അനുവദിക്കുകയും ചെയ്യുന്നു, ഇത് നിങ്ങൾക്ക് N സംഖ്യകൾ നൽകുമെന്ന് കരുതുന്നു. ഓരോ വരിയിലും നിങ്ങൾക്ക് ഒരു മാലോക്കിൽ (malloc)

today, the function will go and look at the space allocated or reserved for it and remove

നിന്ന് ലഭിക്കും, കൂടാതെ M വരികളുണ്ട്, അത് നിങ്ങൾക്ക് ഒരു MxN മാട്രിക്സ് നൽകുന്നു.

the reservation. So, that space can be used by the program, ah.. some other part of the

ഞങ്ങൾ ആദ്യം ചെയ്തത് malloc(sizeof(int)) ആണ്. നിങ്ങൾക്ക് അവ ലഭിച്ചുവെന്ന് പറയാം, നിങ്ങൾക്ക്

program. So, this free takes care of that and when you return it, you have already taken

M ഇന്റീജർ പോയിന്ററുകളും (integer pointer) ലഭിച്ചു. അവയൊന്നും പോയിന്റ് (point) ചെയ്യുന്നില്ല, കാരണം മാലോക്ക് (malloc)

care of whatever allocation you have done, you have removed your reservation.

സമാരംഭിക്കുന്നില്ല. അതിനാൽ, നിങ്ങൾക്ക് എന്ത് ലഭിക്കും? മല്ലോക്ക് (malloc) ഒരു

So, now I am going to see show you a sequence of ah.. various things and I want to argue

പോയിന്റർ (pointer) 10 ലേക്ക് നൽകും, 10 വരികൾ പറയാം. നിങ്ങൾ‌ക്ക് പോയിന്ററുകൾ‌ (pointer) ലഭിക്കും .. ഒരു

about, why something is correct or why something is incorrect. So, lets look at the function

കൂട്ടം പോയിൻററുകൾ‌, ഇവ ഇൻ‌റിജർ‌ അറേകളിലേക്ക് (integer array) പോയിന്റു (point) ചെയ്യുന്നു. ഇടത്

on the left side. So, int star f, so f is a function and ah.. i is a local variable

വശത്ത് ഒരു പോയിന്ററിലേക്ക് (pointer) ഒരു പോയിന്റർ (pointer) പ്രതീക്ഷിക്കുന്നുവെന്ന് int ** പറയുന്നു. ഇത് ഒരു പൂർണ്ണസംഖ്യയിലേക്കുള്ള പോയിന്റർ (pointer) അല്ല.

within the function and you you are returning address to the local variable right. So, thats

ഒരു പൂർണ്ണസംഖ്യയിലേക്കുള്ള പോയിന്ററിലേക്കുള്ള (pointer) പോയിന്റർ (pointer). ഈ പോയിൻററുകൾ‌ (pointer) ഉണ്ടെന്ന് നിങ്ങൾ‌ക്കറിയാമെങ്കിൽ‌, അവ ഇപ്പോൾ‌ പത്ത്

what this int star does. So, int star means you are returning pointer to an integer. Is

വ്യത്യസ്ത വരികളിലേക്ക് പോയിന്റു (point) ചെയ്യാൻ തയാറാണ്, പക്ഷേ നിങ്ങൾ‌ ഇതുവരെ വരികൾ‌ക്കായി

this something that you can do? This is not possible, because when the function

സ്ഥലം അനുവദിച്ചിട്ടില്ല, അത് ഒരു ലൂപ്പിനുള്ളിൽ

gets returned i is a local variable, i gets destroyed, its not correct to track the address

(loop) നടക്കുന്നു. ഈ ലൂപ്പ് (loop) i 0 മുതൽ M -1 വരെ, നിങ്ങൾ ഒരു സമയം ഒരു വരി അനുവദിക്കുകയും

of i anymore. So, this is not correct. Its deallocated i, you cannot track it anymore. Lets look at this function on the right side, its also supposed to return an integer star, its its returning a pointer to an integer. So, here you have a local variable called array, which is an array of 10 integers and you return array which means, you are returning

ഓരോ വരിയുടെയും വലുപ്പം N പൂർണ്ണസംഖ്യകളുമാണ്. ഇത് N നിരകളിലൂടെ M വരികൾ അനുവദിക്കുന്ന അടിസ്ഥാന മാർഗമാണ്. അവസാനം, നിങ്ങൾക്ക്

the location of the 0th element of array. But again you this return array is supposed

യഥാർത്ഥത്തിൽ M N ഘടകങ്ങളുണ്ട്. വാസ്തവത്തിൽ, ഇത്

to ah.. return a pointer to the 0th location. But since array is local to make_array, array

ലഭിച്ചുകഴിഞ്ഞാൽ നിങ്ങൾക്ക് ഘടകങ്ങൾ ആക്സസ് (access) ചെയ്യുന്നതിന് p[i][j] ഉപയോഗിക്കാം. p എന്നത് ഒരു പൂർണ്ണസംഖ്യയിലേക്കുള്ള പോയിന്ററിലേക്കുള്ള

gets destroyed when you return from make_array. So, you are having a pointer that is actually

പോയിന്ററാണ്. അടിസ്ഥാന ഘടകങ്ങളിലേക്ക് പോകാൻ നിങ്ങൾക്ക് p[i][j] ഉപയോഗിക്കാം.

pointing to a location that you cannot claim to be yours anymore. So, this is a problem,

ഇത് ചെയ്തിട്ടില്ലെങ്കിലോ p[i][ j] p ആക്സസ് (access) ചെയ്യുന്നത് തെറ്റാണ്. ഈ രണ്ട് മാലോക്കുകളും (malloc)

so if you do this, sometimes it will may look like this whole thing is actually working.

ചെയ്തിരിക്കണം, നിങ്ങൾ പൂർണ്ണസംഖ്യകളിലേക്ക്

So, this might work, because when you return back from this make_array, may be the space

10 പോയിന്ററുകൾക്കായി (pointer) ഒരു മാലോക്ക് (malloc) ചെയ്തിരിക്കണം, കൂടാതെ ഓരോ പോയിന്ററിനും

is still containing all the values, nobody reclaimed it.

(pointer) ഒരു വരിയിലേക്ക് സൂചിപ്പിക്കാൻ നിങ്ങൾ

So, when you go back to that location, you still see the values. But if you are unfortunate,

അനുവദിച്ചിരിക്കണം .. n നമ്പറുകൾ (number). അത് നമുക്ക് N നിരകളുടെ 10 വരികൾ നൽകും. . മൾട്ടി-ഡൈമെൻഷണൽ

this ah.. memory location that you didn't want anymore got used up somewhere else and

അറേകൾ (multidimensional array) എങ്ങനെ ഡീലോക്കേറ്റ് (deallocate) ചെയ്യാമെന്ന് നോക്കാം. ഓരോ വരിയിലും ഓരോ

now you are actually accessing something that is not ah.. supposed to be used by you. So,

വരിയിലേക്കും പോയിന്റു (point) ചെയ്യുന്ന 10 പോയിന്ററുകൾ

the space if its reallocated this becomes unpredictable, but if the space is not reallocated to anyone else, it might work. In general, you should not rely on the space to be unallocated. You should not believe that oh I am hoping that its unallocated, let me go and use it. Thats not correct. You should treat, you should be conservative and you should say that I

(pointer) വലുപ്പ N ഘടകങ്ങളാണെന്ന് പറയാൻ ഇപ്പോൾ നിങ്ങളെ

will assume that its going to be reallocated. Therefore, I will free it up here and I will not pass pointers back to local variables. So, if you want to really pass ah.. pointers to local variables or anything that you allocate

അനുവദിക്കുന്നു. ഇവയിൽ നിങ്ങൾക്ക്

inside, you first of all do dynamic allocation and you pass on a pointer. This is correct. Similarly, here you did dynamic allocation, so these 10 integers are not going to be deallocated when the function returns and because of that its ok to return a pointer to that. So, you allocate with malloc and return the pointer, so this is allowed.

M ഉം N ഉം ഉണ്ട്. നിങ്ങൾ ചെയ്യുന്നതെന്തെന്നാൽ,

So, now lets go and look at, how to allocate multidimensional arrays. Its not just that we look for single dimensional arrays or an array of integers, array of characters and so on. Many times you want to build matrices or 3D ah.. matrices and so on, how do we do it. So, we start with int star star p. So, the meaning of that is p is a pointer to a

നിങ്ങൾ ആദ്യം പോയി p

pointer to an integer. So, lets see what that means. So, p is not pointing to an integer, p in turn is pointing to another pointer which is in turn pointing to a some integer. So, thats the meaning of int star star p. So, p is supposed to be pointing to another pointer which is in turn pointing to an integer. Alright. And int is a so, int i is declaring

space for an integer i right. Now, lets see how to allocate a multidimensional array. So, the first thing you do is lets say I want M rows and N columns right. So, the first thing you do is allocate M pointers first. So, we have M pointers that are being allocated and this is not going to get pointer to anything. So, you have M pointers, we do that first

and then each pointer variable, you now make an allocation of N integers. So, you allocate M pointers to integers and then, you allocate N integers at a time and this will suppo this is supposed to give you N integers. So, each row you get from a malloc and you have M rows that gives you a M cross N matrix. So, lets break this down, the first thing we have done

is a malloc of sizeof int star. So, sizeof int star is sizeof integer pointer, not sizeof integer its sizeof integer pointer and we want M integer pointers. Lets say you got them, you got M integer pointers and ah.. they are not going to point to anything, because malloc does not initialize. So, what do you get in return? Malloc will return a

pointer to 10, lets say 10 rows. You will get pointers to ah.. an array of pointers and these are pointing to 10 integer arrays right. So, an int star star tells you that the left side is expecting a pointer to a pointer. Its not a pointer to an integer. Its a pointer to a pointer to an integer. And once you have that you have all these

pointers, which can which are ready to now point to the ten different rows, but you have

not allocated space for the rows yet and that is done inside a loop. So, this loop goes from i equals 0 to M minus 1 and you are allocating one row at a time and each row is of size N integers. So, thats what you have here. So, this is a very ah.. basic way in which

free ചെയ്യുക, നിങ്ങൾ 0 മുതൽ M - 1 വരെ ആവർത്തിക്കുന്നു. ഞാൻ free(p[i)) എന്ന് പറയുമ്പോൾ, p [0] ൽ ആരംഭിക്കുന്നു അത് ഇല്ലാതാക്കും. P[1] ഈ വരിയെ ഡീലോക്കേറ്റ്

M rows by N columns is allocated. At the end, you actually have M N elements.

ചെയ്യും, അങ്ങനെ, p[m-1] ഈ വരിയെ ഡീലോക്കേറ്റ് ചെയ്യും. എല്ലാ സംഖ്യകളെയും

In fact, once you have this you can use p of i j to access the elements. So, just like

ഡീലോക്കേറ്റ് (deallocate) ചെയ്യുന്നതിലൂടെ നിങ്ങൾ ചെയ്തു, പക്ഷേ നിങ്ങൾ ശരിയായി അനുവദിച്ച

you would access array of i comma j, two dimensional array of i comma j, p is a pointer to a pointer

ഈ പോയിന്ററുകളും (pointer) നിങ്ങൾ അനുവദിച്ച രീതിയും ഈ 10 കാര്യങ്ങളിലേക്കാണ് വിരൽ ചൂണ്ടുന്നത്,

to an integer. You can use p of i comma j to get to the basic elements. So, it would be incorrect to access p of i j, if you have not done this or if you have not done this. You should have done both these mallocs, so you you should have done a malloc for 10 pointers to integers and you should have allocated for each pointer to point to a row of ah..

എന്നിരുന്നാലും അവ ഒരു കൂട്ടം പോയിന്ററുകളാണ് (pointer). നിങ്ങൾ p free ചെയ്യുമ്പോൾ, ഇത് എല്ലാ പോയിന്ററുകളും

N numbers. So, that will give us 10 rows by N columns.

. So, lets look at how to deallocate multidimensional arrays. So, right now you have lets say 10 pointers pointing to one row each and each row, is of size N elements. So, you have M of these and you have N of those. What you do is, you first go and do free of p of i and you iterate i from 0 to M minus 1. So,

(pointer) ഡീലോക്കേറ്റ് (dealloctae) ചെയ്യുന്നു. ഈ സമയത്ത്, p എന്ന പോയിന്റർ (pointer) സാധുവായ

when you say free p of i, you start with p of 0, p of 0 free p of 0 will deallocate that.

ഒന്നും ചൂണ്ടിക്കാണിക്കുന്നില്ല, നിങ്ങൾ p നെ NULL ന് തുല്യമാക്കുന്നു. ദ്വിമാന അറേകൾ‌ (array) അനുവദിക്കാൻ‌ താൽ‌പ്പര്യപ്പെടുമ്പോൾ‌,

free p of 1 will deallocate this row, p of 2 being freed will deallocate this row and

ആദ്യം ഒരു പോയിന്ററിലേക്ക് (pointer) അടിസ്ഥാന ഡാറ്റാ തരം നിങ്ങൾ‌ ഒരു സമയത്ത്‌ ആവർത്തിക്കുകയും

so on, free p of M minus 1 will deallocate this row.

വരികൾ‌ അനുവദിക്കുകയും ചെയ്യുന്നു. ഡീലോക്കേറ്റ് (deallocate) ചെയ്യുമ്പോൾ, എല്ലാ വരികളും ഒരു

So, you have done with deallocating all the integers, but you still have all these pointers

സമയം ഡീലോക്കേറ്റ് (deallocate) ചെയ്യുകയും പോയിന്ററുകളുടെ (pointer) നിര തന്നെ ഡീലോക്കേറ്റ് (dealloctae) ചെയ്യുകയും ചെയ്യുന്നു. പോയിന്ററുകൾ

that you allocated right and the way you allocated that was p was pointing to all these 10 things

(pointer) അനുവദിക്കുകയും ഡീലോക്കേറ്റ് (deallocate) ചെയ്യുകയും ചെയ്യുന്ന രീതിയാണിത്. ആദ്യം എല്ലാ വരികളും സ്വതന്ത്രമാക്കുക, പോയിന്ററുകളുടെ

as though, they were an array of pointers. And when you do free of p, it also deallocates

(pointer) നിര സ്വതന്ത്രമാക്കുക, NULL ലേക്ക് p പോയിന്റ് (point) ഉണ്ടാക്കുക, നിങ്ങൾ പൂർത്തിയാക്കി.

all the pointers. At this point, the pointer p is in is not pointing to anything valid, you make p equals NULL. So, essentially what you have is you have a sequence of steps. When you want to allocate two dimensional arrays, you first go and allocate a two a

പുതിയ അലോക്കേഷൻ (allocation) ഉണ്ടാകുന്നതുവരെ നിങ്ങൾ NULL ലേക്ക് വിരൽ ചൂണ്ടുന്നു.

ah.. a pointer to a pointer to ah.. the basic data type and you iterate over that one at a time and allocate rows. When you deallocate, you deallocate all the rows one at a time and then you deallocate the array of pointers itself. So, this is way this is the way you allocate and deallocate pointers. So, first free all the rows, free the array of pointers,

ഇതുപയോഗിച്ച് ഞങ്ങൾ ഈ പ്രഭാഷണത്തിൽ പോയിന്ററുകളെക്കുറിച്ചും (pointer) ഡൈനാമിക് മെമ്മറി അലോക്കേഷൻ (dynamic memory

make p point to the NULL and you are done. So, this is ah.. you keep p will keep pointing to NULL, until there is new allocation. So, with this we are end of at this lecture about pointers and how to use dynamic memory allocation for ah.. not just 1D arrays, it can also be

allocation) എങ്ങനെ ഉപയോഗിക്കാമെന്നതിനെക്കുറിച്ചും പറഞ്ഞു. 1D അറേകൾ (array) മാത്രമല്ല, ഇത് 2D അറേകളും (array) ആകാം.

2D arrays. The basic element that you stored in an array can be an integer, can be a float,

നിങ്ങൾ ഒരു അറേയിൽ (array) സംഭരിച്ചിരിക്കുന്ന അടിസ്ഥാന ഘടകം ഒരു പൂർണ്ണസംഖ്യ ആകാം,

it can be a character, it can also be structures. You can have a 2D matrix of structures, where

ഒരു ഫ്ലോട്ട് (float) ആകാം, അത് ഒരു കാരക്ടർ (character) ആകാം, അത് സ്ട്രക്ച്ചറുകളും (structure) ആകാം. നിങ്ങൾക്ക്

each element could be an integer ah.. containing x, an integer containing y may be you have a 2D array of pointers thats possible. So, in in so to summarise what we have is

സ്ട്രക്ച്ചറുകളുടെ (structure) 2 ഡി മാട്രിക്സ് (matrix) ഉണ്ടായിരിക്കാം, അവിടെ ഓരോ ഘടകവും ഒരു പൂർണ്ണസംഖ്യ ആകാം x അടങ്ങിയിരിക്കുന്നു, y അടങ്ങിയ ഒരു സംഖ്യ ആകാം, പോയിന്ററുകളുടെ

(pointer) 2D അറേ (array) ആവാം. സംഗ്രഹിക്കാൻ നമുക്ക്

we have a mechanism, a general mechanism by which as long as I know the size of the basic

ഒരു മെക്കാനിസം (mechanism) ഉണ്ട്, എനിക്ക് ആവശ്യമുള്ള അടിസ്ഥാന ഡാറ്റാ (data) തരത്തിന്റെ വലുപ്പം

data type that I want, I will allocate bytes as many as I need. I will get a pointer done

എനിക്കറിയാവുന്നിടത്തോളം കാലം, എനിക്ക് ആവശ്യമുള്ളത്ര ബൈറ്റുകൾ (byte) അനുവദിക്കും. എനിക്ക് ഒരു പോയിന്റർ (pointer) ലഭിക്കും ഞാൻ അത് ഉചിതമായ ഡാറ്റാ

by ah.. returned by malloc, I should point it to the appropriate data type and whenever

(data) തരത്തിലേക്ക് ചൂണ്ടിക്കാണിക്കണം, കൂടാതെ ഈ മെമ്മറി (memory) ഇനി ആവശ്യമില്ലെങ്കിൽ,

this ah.. memory is not needed anymore, you should be really careful and deallocate the

നിങ്ങൾ ശരിക്കും ശ്രദ്ധാലുവായിരിക്കുകയും മെമ്മറി (memory) ഡീലോക്കേറ്റ് (deallocate) ചെയ്യുകയും വേണം. നിങ്ങളുടെ മെമ്മറി (memory) ഹോഗ്

memory. So, that your memory is not hogged, your program itself further down may need

(hog) ചെയ്യാത്തതിനാൽ, നിങ്ങളുടെ പ്രോഗ്രാമിന് (program) കൂടുതൽ താഴേക്ക് കൂടുതൽ മെമ്മറി (memory)

more memory, if you didn't free up something that you don't need, you may get stuck. So,

ആവശ്യമായി വന്നേക്കാം, നിങ്ങൾക്ക് ആവശ്യമില്ലാത്ത എന്തെങ്കിലും സ്വതന്ത്രമാക്കിയില്ലെങ്കിൽ, നിങ്ങൾ കുടുങ്ങിപ്പോയേക്കാം.

this end brings us to the end of the lecture. Thank you.

ഇതോടെ ഈ പ്രഭാഷണം അവസാനിക്കുന്നു.