Introduction to Strings Programming, Data Structures and Algorithms English Malayalam

Introduction to StringsYouTube↗ IA↗(long shot)
People & Blogs 1.3K views 2 likes 0 dislikes 30 Jan 2018

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

അറേകൾക്ക് (array) പകരം പോയിന്ററുകൾ (pointer)

Let us see, what I meant by pointers being a replacement for arrays.

എങ്ങനെ ഉപയോഗിക്കാമെന്ന് നോക്കാം. ഈ ചെറിയ കോഡ് (code) നോക്കാം. int myArray ഉണ്ട്. ഇത് ശരിക്കും എന്താണ് ചെയ്യുന്നതെന്ന് നമുക്ക് ചിന്തിക്കാം. int myArray ഇടത്, വലത് ചതുര ബ്രാക്കറ്റ് (bracket)

So, let us look at this small piece of code here. So, we have int myArray equals this. So, let us think about, what it really is doing? So, int myArray there is a left and

മൂല്യങ്ങളുടെ ഒരു പട്ടികയ്ക്ക് തുല്യമാണ്. ഇത് വലതുവശത്ത് നിന്ന് മൂല്യങ്ങളുടെ ഗണം എടുക്കുന്നു. 1, 23, 17, 4, -5, 100 എന്നിവയുണ്ട്, ആറ് മൂല്യങ്ങളുണ്ട്. int myArray യഥാർത്ഥത്തിൽ

right square bracket equals a list of values. So, what this does is, it takes the set of

ഒരു അറേയാണ് (array) , അതിന് ആറ് മൂല്യങ്ങൾ എടുക്കാം. എന്റെ അറേയുടെ (array) വലുപ്പം ആറ് മൂല്യങ്ങളാണ്, നമുക്ക് *ptr , i ഉണ്ട്. myArray 6 വലുപ്പത്തിന്റെ

values from the right side. So, we have 1, 23, 17, 4, minus 5 and 100, there are six

ഒരു ശ്രേണി ആയിരിക്കണമെന്ന് വ്യക്തമായി പറയുന്നതിനുപകരം, വലതുവശത്ത് എത്ര മൂല്യങ്ങളുണ്ടെന്ന് മനസിലാക്കാൻ കംപൈലറിനെ (compiler) അനുവദിച്ചു.

values. So, int myArray is actually an array, which can take six values. So, the size of

അത് അടിസ്ഥാനമാക്കി എന്റെ അറേയ്‌ക്കായി (array) വലുപ്പം എടുക്കുക. ഈ സാഹചര്യത്തിൽ myArray- ന്റെ വലുപ്പം 6 ആണ്. നമുക്ക് *ptr ഉം i ഉം

myArray is six values, then we have star ptr and i. So, instead of explicitly saying myArray should be an array of size 6, we let the compiler,

ഉണ്ട്. ഈ വരിയിൽ നമുക്കുള്ളത്, i എന്ന് വിളിക്കുന്ന ഒരു ഇന്റിജെർ (integer), myArray എന്ന് വിളിക്കുന്ന ഒരു ഇന്റിജെർ അറേ (integer array), ptr എന്ന് വിളിക്കുന്ന ഒരു ഇന്റിജെർ പോയിന്റർ (integer pointer) .

നിങ്ങൾക്ക് 1 ആം വരിയിൽ അതാണ് ഉള്ളത്, അടുത്ത

figure out how many values are there on the right side? Based on that appropriately take

വരിയിൽ ptr =&myArray[0]. ptr ഇപ്പോൾ myArray ന്റെ 0 ആം സ്ഥാനത്തേക്ക്

the size for myArray. So, in this case the size of myArray is 6. So, following that we

പോയിന്റ് ചെയ്യുന്നു. നിങ്ങൾക്ക് ഇത് ptr=myArray ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കാനും കഴിയും, അതും സാധുവാണ്, അത് അതേ കാര്യം ചെയ്യുന്നു. നമുക്ക് ഇവിടെ ഈ ലൂപ്പ് (loop) നോക്കാം. printf myArray [% d]=%d myArray പ്രിന്റ്

have star ptr and i. So, what we have in this line is, we have two integers. Sorry, one

(print) ചെയ്യാനാണ്. ഞാൻ ഈ വരിയെ a എന്ന് വിളിക്കാൻ പോകുന്നു, അടുത്ത വരിയിൽ, address

integer called i, one integer array called myArray and one integer pointer called ptr.

ptr +%d =% d, ആദ്യ % d ന് i നൽകുന്നു, രണ്ടാമത്തെ %d, *ptr+i പ്രിന്റുചെയ്യേണ്ട വേരിയബിളായി (variable) നൽകുന്നു. ഇതിന്റെ അർത്ഥമെന്താണെന്ന്

So, that is what you have in line 1 and in the next line we have ptr equals ampersand

നമുക്ക് നോക്കാം. ആദ്യ വരിയിൽ, അറേയുടെ ഇൻഡെക്‌സും (index) i =0 മുതൽ 5 വരെ യുള്ള മൂല്യവുമാണ്

of myArray of 0. So, ptr is now pointing at 0th location of myArray. You can also replace

അച്ചടിക്കുന്നത്. അതിനാൽ, myArray ന് 6 മൂല്യങ്ങളുണ്ട്, അത് 0 മുതൽ 5 വരെ പോകുന്നു, അടുത്ത വരിയിൽ ptr+ എന്ന വിലാസം അടങ്ങിയിരിക്കുന്നു. നിങ്ങൾ ലൂപ്പ് (loop)

this with ptr equals myArray, that is also valid and it does the same thing. So, let

കാണുകയാണെങ്കിൽ i 0, 1, 2, 3 എടുക്കും. Ptr +0 ന്റെ ഉള്ളടക്കങ്ങൾ‌, Ptr +1, Ptr +2 , എന്നിങ്ങനെ

us look at this loop here. So, printf myArray of percentage d equals percentage d. So, it

Ptr +5 വരെ ഉള്ളടക്കങ്ങൾ‌ കാണും. *ptr +i അർത്ഥമാക്കുന്നത്, ptr +i എടുക്കുക, ബേസിൽ (base) നിന്നും ഉചിതമായ എണ്ണം സ്ഥാനങ്ങളിലൂടെ അതിനെ നീക്കുക, * ഓപ്പറേറ്റർ

is saying that print myArray of some integer equals some integer i comma myArray of i.

(operator) ഉപയോഗിച്ച് അതിനെ ഡീറെഫെറെൻസിംഗ് (dereferencing )ചെയ്യുക , ഞാൻ‌ ഇതിനെ ലൈൻ‌ ബി (line

So, I am going to call this line a and in the next line, we have contents in address

B) എന്ന് വിളിക്കാൻ‌ പോകുന്നു, നമുക്ക് ഈ പ്രോഗ്രാം (program) എടുത്ത് അത് പ്രവർത്തിപ്പിക്കാം. ഞാൻ ഈ പ്രോഗ്രാം (program) എഡിറ്ററിൽ (editor)

ptr plus percentage d equals percentage d and for the first percentage d, we give i

കോപ്പി (copy) ചെയ്തിട്ടുണ്ട്. ഇത് കോംപൈൽ ചെയ്തു റൺ ചെയ്യാം ഔട്ട്‌പുട്ടിൽ (output) എന്താണ് സംഭവിക്കുന്നതെന്ന് നമുക്ക് നോക്കാം. ഔട്ട്‌പുട്ടിൽ (output)

എന്താണ് അച്ചടിച്ചിരിക്കുന്നതെന്ന് കാണാൻ കുറച്ച് സമയമെടുക്കാം.

and for the second percentage d, we give star of ptr plus i as the variable to be printed. So, let us see what this means. So, in the first line, it is straight forward, you are printing the index of the array as well as the value contained in the index for i equals

ആദ്യ വരി myArray [0]= 1, addressptr+ 0 =1. പ്രോഗ്രാമിൽ (program) അറേ (array) കാണാം. myArray 1, 23, 17, 4, - 5, 100 എന്നിവയാണ്. myArray [0 ] തീർച്ചയായും 1 ഉം *ptr+ 0 1 ലേക്ക് പോയിന്റ് (point) ചെയ്യുന്നു . അതിനാൽ, ഇത് 1 അച്ചടിക്കുന്നു.

0 to 5. So, myArray has 6 values and it goes from

അപ്പോൾ, myArray[1] 23 ഉം ptr+1 ptr ൽ നിന്ന് ഒരു പടി

0 to 5 and the next line contains an address ptr plus. So, if you see the loop, it will

അകലെയുള്ള സ്ഥലത്തേക്ക് പോയിന്റുചെയ്യേണ്ടതുണ്ട്. ptr myArray[0] എന്ന അറേയിലേക്ക് (array) മാത്രമാണ് പോയിന്റ് (point) ചെയ്യുന്നതെന്ന് ഓർക്കുക. അതിൽ നിന്ന് അടുത്ത മൂലകം a [1] ആണ്. ptr+1 എന്നത് a [1] ന്റെ

take I will take 0, 1, 2, 3 and so, on. You will see contents of ptr plus 0, contents

വിലാസമാണ്, കൂടാതെ നിങ്ങൾ *ptr + 1 ചെയ്യുമ്പോൾ, നിങ്ങൾ a യുടെ 1 ആം സ്ഥാനത്ത് അടങ്ങിയിരിക്കുന്ന

of ptr plus 1, contents of ptr plus 2 and so, on, all the way up to ptr plus 5. So,

മൂല്യം ചോദിക്കുന്നു, അതായത് നിങ്ങൾ 1 ന്റെ മൂല്യം ചോദിക്കുന്നുവെന്നും ഇത് തുടരുന്നുവെന്നും അർത്ഥമാക്കുന്നു. * ptr+5 മൂല്യം ചോദിക്കുന്നു.

that is what you are seeing on this. And star of ptr plus i means, take ptr plus i, which

*ptr+5 a [5 ] ന്റെ ഒരു സ്ഥാനത്താണ്, അത് 100 ആയിത്തീരുന്നു, അതാണ് നിങ്ങൾ ഇവിടെ കാണുന്നത്. പ്രോഗ്രാമിൽ ഒരു ചെറിയ മാറ്റം വരുത്താം,

means move it by appropriate number of locations from the base and dereference it using the star operator and I am going to call this, line B. So, I will tell you quickly, why I

മാറ്റാൻ കഴിയാത്ത ഒന്നാണ് myArray എന്ന് കാണിക്കാൻ ഞാൻ ആഗ്രഹിക്കുന്നു. ഞാൻ ഇത് ചെയ്യുന്നു myArray++. myArray 23 ലേക്ക് പോയിന്റുചെയ്യുക (point) എന്നതാണ്. അതിനാൽ, myArray[0] 23 ആയിരിക്കണമെന്നും myArray[1] 17 ആയിരിക്കണമെന്നും

want the lines to be named A and B. But, let us take this program and run it.

ഞാൻ ആഗ്രഹിക്കുന്നു. അതിനാൽ, ഞാൻ myArray 1 വർദ്ധിപ്പിക്കാൻ ശ്രമിക്കുന്നു. ഞാൻ ഇത് 1 ലേക്ക് പോയിന്റ്

So, I have already taken this program and copied it into my editor.

(point) ചെയ്യില്ല, അത് 23 ലേക്ക് പോയിന്റ്ചെയ്യുന്നു (point). അതിനാൽ, നമുക്ക് ഇത് കം പൈൽ ചെയ്യാം.

And let me compile it and run it.

ഇവിടെ സംഭവിക്കുന്ന പിശക് നോക്കാം. വാസ്തവത്തിൽ, കംപൈലർ (compiler) ആരംഭിക്കുകയും 13-ാം വരിയിൽ പിശക്

So, let us see what is happening in the output. So, let us take some time to see, what is

ചൂണ്ടിക്കാണിക്കുകയും ചെയ്യുന്നു. ഇൻക്രിമെന്റ് ഓപ്പറാൻഡായി (increment operand) l ആവശ്യമാണ്. അതിനാൽ, ഇത് സി (C) യ്ക്ക് വളരെ ഉപയോഗപ്രദമായ പിശകല്ല,

printed in the output. So, the first line is myArray of 0 equals 1, contents in address

പക്ഷേ സി (C) യ്ക്കുള്ള പല കംപൈലറുകളും (compiler) നിങ്ങൾക്ക് പിശകുകൾ നൽകുന്നു, ഇത് അല്പം

ptr plus 0 equals 1 that is what it says. So, let us see myArray in the program. So,

മാറ്റാം, ഞാൻ പറഞ്ഞതുപോലെ, ഇത് myArray myArray+1 എന്ന് പറയുന്നതിന് തുല്യമാണ്. നമുക്ക് ഇത് കംപൈൽ (error) ചെയ്യാം, നിങ്ങൾ

myArray is 1, 23, 17, 4, minus 5 and 100. So, myArray of 0 is indeed 1 and ptr plus

ഇപ്പോഴും അതേ പിശക് കാണുന്നു. വലത് വശത്ത്, ടൈപ്പ് (type) int [6 ] int* അസ്സയിൻ (assign) ചെയ്യാൻ നിയോഗിക്കുമ്പോൾ

0 which means the contents of ptr plus 0 is star of ptr plus 0. So, ptr plus 0 is ptr

ഇൻകോംപാറ്റിബിൾ ടൈപ്പ് (incompatible type) എന്ന എറർ (error) പറയുന്നു. വലതുവശത്ത് ഇത് myArray+ 1 ചെയ്യുന്നു, അതിനർത്ഥം നിങ്ങൾ myArray യിൽ നിന്ന് ഒരു സ്ഥലം ചോദിക്കുന്നുവെന്നും ഇടതുവശത്ത് നിങ്ങൾ

ഇത് myArray യ്ക്ക് നൽകുകയാണെന്നും അർത്ഥമാക്കുന്നു.

itself and star of ptr is pointing to 1. So, it is printing 1.

ഇതും ഒരു കംപൈലേഷൻ എറർ (compilation error) നൽകുന്നു. അതിനാൽ, നിങ്ങൾ എഴുതുന്നതിനെ അടിസ്ഥാനമാക്കി, അത് പിശക് മാറ്റുകയാണ്. പക്ഷേ, അടിസ്ഥാന

Then, myArray of 1 is 23 and ptr plus 1 is supposed to point at the location one step

കാര്യം, myArray പോയിന്റ് (point) ചെയ്യേണ്ടത് എന്താണെന്ന് മാറ്റാൻ അനുവദിക്കുന്നില്ല,. അതേസമയം, ഞാൻ ptr = myArray ചെയ്തിട്ടുണ്ടെങ്കിൽ ... നമുക്ക് 13-ാം വരി നോക്കാം. ഞാൻ ഇത്

away from ptr. So, remember ptr is only pointing at myArray of 0. So, one element away from that is a of 1. So, ptr plus 1 is the address of a of 1 and when you do star of ptr plus

കംപൈൽ (compile) ചെയ്യുകയാണെങ്കിൽ, അത് സാങ്കേതികമായി ഒരു പ്രശ്നമല്ല. കാരണം, ഈ വരിയിൽ പോലും, ptr = myArray [0] എന്നത് ptr = myArray ന് തുല്യമാണ്. . ഇവ എ, ബി (A, B) വരികളാണെന്ന്

1, you are asking for the value contained in 1th location of a, which means you are

ഞാൻ പറഞ്ഞു, ഇത് എന്തുകൊണ്ട് ഉപയോഗപ്രദമാണെന്ന് നോക്കാം. ++ptr , ptr++ എന്നിവ രണ്ടും ptr+1 എന്ന് പറയുന്നതിന് തുല്യമാണ്, വ്യത്യസ്ത സമയങ്ങളിൽ നിങ്ങൾ ptr നെ 1 വർദ്ധിപ്പിക്കുകയാണ്. ++ptr , ptr++ എന്നിവ തമ്മിൽ

asking for the value of a of 1 and this goes on. So, ptr plus 5 is asking for the value.

വ്യത്യാസമുണ്ട്, ++ptr പ്രീ ഇൻ‌ക്രിമെൻറ് ഓപ്പറേറ്റർ‌ (pre increment operator) എന്ന് വിളിക്കുന്നു.

So, star of ptr plus 5 will get the value, which is at a of 5 and it happens to be 100

ptr ന്റെ മൂല്യം വർദ്ധിപ്പിക്കുക, എന്നിട്ട് അത് ഉപയോഗിക്കുക, ptr++ പോസ്റ്റ് ഇൻക്രിമെന്റ് ഓപ്പറേറ്ററാണ് (post increment operator) . Ptr ന്റെ നിലവിലെ മൂല്യം ഉപയോഗിക്കുക,

and that is what you see here.

പിന്നീട് ptr ന്റെ മൂല്യം വർദ്ധിപ്പിക്കുക.

So, let us do a small change to the program and I want to show that myArray is something

പക്ഷേ, നിങ്ങൾ ഈ ചെറിയ വ്യായാമം ചെയ്യണമെന്ന് ഞാൻ ആഗ്രഹിക്കുന്നു. ബി വരി മാറ്റുക. അതിനാൽ, നിങ്ങൾ ബി (B) വരി നോക്കുകയാണെങ്കിൽ, അത് വിലാസത്തിലെ

that cannot change. So, let us say I do this, myArray plus plus. So, what I want myArray

ഉള്ളടക്കങ്ങൾ പറയുന്നു ptr + % d is i, *(ptr ++) അത് *ptr++ ലേക്ക് മാറ്റി വീണ്ടും പ്രവർത്തിപ്പിക്കുക, ഒരിക്കൽ കൂടി ആ വരി *++ptr ലേക്ക് മാറ്റി

to do is, point to 23. So, I want myArray of 0 to be 23, myArray of 1 to be 17 and so,

വീണ്ടും പ്രവർത്തിപ്പിക്കുക. ഈ സ്ലൈഡിലുള്ള (slide) ഈ പ്രോഗ്രാം(program) നിങ്ങൾ എടുക്കുന്നു, പക്ഷേ

on. Therefore, I am trying to increment myArray by 1. So, I do not, it will not point to 1

ഈ വരി അല്ലെങ്കിൽ ഈ വരി ഉപയോഗിച്ച് ബി (B) വരിയിൽ മാറ്റങ്ങൾ വരുത്തുക, കംപൈൽ (compile) ചെയ്ത് പ്രവർത്തിപ്പിക്കുക, എന്തുകൊണ്ട് സംഭവിക്കുന്നു,

anymore, it is supposed to be pointing at 23. So, let us try and compile this.

അതിനെക്കുറിച്ച് ഒരു കാരണം പരീക്ഷിക്കുക. നമുക്ക് മുന്നോട്ട് പോകാം, സിയിൽ (C) ഉപയോഗപ്രദമായ മറ്റൊരു കാര്യമുണ്ട്, അതിനെ സൈസ് ഓഫ് ഓപ്പറേറ്റർ

Let us try and compile that and let us look at this, error that happens. In fact, the

(sizeof operator) എന്ന് വിളിക്കുന്നു. ഇത് പോയിന്ററുകൾക്ക് (pointer) നേരിട്ട് പ്രസക്തമല്ല,

compiler starts and points error at line number 13. It says, l value is required as increment

എന്നാൽ ഇത് ഇപ്പോൾ സംസാരിക്കാൻ ആഗ്രഹിക്കുന്ന ഒരു കാര്യമാണ്, പിന്നീട് കുറച്ച് കാര്യങ്ങൾ വിശദീകരിക്കാൻ ഈ സൈസ്ഓഫ് ഓപ്പറേറ്റർ (sizeof) ഉപയോഗിക്കുക. ഈ പ്രോഗ്രാമിൽ (program)

operand. So, it is not a very useful error to C, but many compilers for C actually give

int size, chr size , float size എന്നിങ്ങനെ മൂന്ന് സംഖ്യകളുണ്ട്, പേര് സൂചിപ്പിക്കുന്നതുപോലെ, നിങ്ങൾ ഒരു സംഖ്യയുടെ

you errors, that are slightly cryptic. In this case, what it is saying is. So, let us

വലുപ്പമോ ഒരു കാരക്ടറിന്റെ (character) വലുപ്പമോ ഫ്ലോട്ടിംഗ് പോയിന്റിന്റെ (floating point) വലുപ്പമോ നോക്കുകയാണ്.

change this a little bit, like I said, this is equivalent to saying myArray is myArray

ഒരു ഇന്റിജെറിന്റെ (integer) വലുപ്പം ചോദിക്കുന്നതിലൂടെ എന്താണ് അർത്ഥമാക്കുന്നത്? ഇന്റിജെർ (integer) യഥാർത്ഥത്തിൽ

plus 1. So, let us compile this, you still see the

മൂല്യങ്ങളുടെ ഒരു കൂട്ടമാണ്, നിങ്ങൾ പോയി യഥാർത്ഥ ലോകത്തെ നോക്കുകയാണെങ്കിൽ, പൂർണ്ണസംഖ്യകളുടെ എണ്ണം പരിധിയില്ലാത്തതാണ്.

same error. On the right side, it says error incompatible types, when assigning to type

നിങ്ങൾക്ക് -ഇൻഫിനിറ്റി (-infinity) മുതൽ +ഇൻഫിനിറ്റി (+infinity) വരെ എല്ലാ വഴികളുമുണ്ട്, ഇത് സി (C) ഭാഷ പിന്തുണയ്ക്കുന്ന ഒന്നല്ല., സാധ്യമായ എല്ലാ സംഖ്യകളും

int of 6 from type int star. So, on the right side it is doing myArray plus 1, which means

നിങ്ങൾക്ക് അവിടെ സംഭരിക്കാനാവില്ല. സി അതിന്റെ വലുപ്പം കുറഞ്ഞത് 4 ബൈറ്റുകളായി (byte) പരിമിതപ്പെടുത്തുന്നു. നിങ്ങൾ sizeof int എന്ന്

you are asking for one location away from myArray and in the left side, you are assigning it to myArray. Even this, it gives a compilation error. So, based on what you write, so, it

പറയുന്നുവെങ്കിൽ, അത് യഥാർത്ഥത്തിൽ ഒരു സംഖ്യയെ പ്രതിനിധീകരിക്കുന്നതിന് ഉപയോഗിക്കുന്ന ബൈറ്റുകളുടെ (byte) എണ്ണം നൽകുന്നു. അതുപോലെ, sizeof char ഒരു കാരക്ടർ (character) സംഭരിക്കുന്നതിന് ആവശ്യമായ ബൈറ്റുകളുടെ

(byte) എണ്ണം നൽകും, കൂടാതെ ഫ്ലോട്ടിംഗ് പോയിന്റിംഗ്

is changing the error. But, the basic point is, it is not letting you change, what myArray should be pointing to. Whereas, if I had done this, let us say

നമ്പർ (floating point number) സംഭരിക്കുന്നതിന് സൈസ് ഓഫ് ഫ്ലോട്ട് (sizeof float) നിങ്ങൾക്ക് നിരവധി ബൈറ്റുകൾ (byte) നൽകും. വ്യത്യസ്ത മെഷീനുകളിൽ (machine) ഇവ വ്യത്യാസപ്പെടാം. എന്നാൽ, അടിസ്ഥാന

പോയിന്റ് നിങ്ങൾ പ്രവർത്തിക്കുന്ന

I did ptr equals myArray, if I did that... So, let us look at line number 13. So, if

മെഷീനായി (machine), ഒരു സംഖ്യ സംഭരിക്കാൻ എത്ര ബൈറ്റുകൾ (byte )ആവശ്യമാണെന്ന് ഇത് നിങ്ങളോട് പറയും. മിക്ക ആധുനിക മെഷീനുകളിലും sizeof integer 4 ബൈറ്റുകളാണ് (byte ) അല്ലെങ്കിൽ അത്

8 ബൈറ്റുകൾ ആകാം. പോയിന്റർ (pointer) ഗണിതവുമായി ബന്ധപ്പെട്ട

I compile it, it is technically not a problem. Because, even in this line, ptr equals myArray

കുറച്ച് കാര്യങ്ങൾ നോക്കാം. ഞാൻ പോയിന്റർ (pointer) ഗണിതത്തിലേക്ക് മടങ്ങുകയാണ്, നിങ്ങൾക്ക് പോയിന്ററുകളും (pointer) പോയിന്ററുകളുമായി (pointer) ബന്ധപ്പെട്ട ഗണിതവും ഉപയോഗിച്ച്

ധാരാളം കാര്യങ്ങൾ ചെയ്യാൻ കഴിയും.

of 0 is actually equivalent to this line, ptr equals myArray.

ഒരേ തരത്തിലുള്ള പോയിന്ററുകൾ (pointer) തമ്മിൽ അസൈൻ (assign) ചെയ്യാൻ കഴിയും, നിങ്ങൾക്ക് ഒരു പോയിന്ററും (pointer) ഒരു ഇന്റിജെറും (integer) തമ്മിൽ കൂട്ടിച്ചേർക്കലും കുറയ്ക്കലും നടത്താം.

. So, I said these are lines A and B, let us

ഇതിനകം ഈ ഉദാഹരണം കണ്ടു, ptr +1 ഉം ptr++ ഉം അങ്ങനെ ചെയ്തു. ptr പോയിന്ററായിരുന്നു

see why this is useful. So, I want to use it, to illustrate something now. So, both

(pointer) + 1 യഥാർത്ഥത്തിൽ ptr ലേക്ക് 1 ചേർക്കുന്നു. എന്നിരുന്നാലും, സി (C) അത് ചെയ്യാൻ

plus plus ptr and ptr plus plus are actually equivalent to saying ptr plus 1, you are incrementing

നിങ്ങളെ അനുവദിക്കുന്നു, ഒരേ അറേയിലെ (array) ഘടകങ്ങളിലേക്ക് പോയിന്റു (point) ചെയ്യുന്ന രണ്ട് പോയിന്ററുകൾ (pointer) നിങ്ങൾക്ക് താരതമ്യം ചെയ്യാൻ കഴിയും,

ptr by 1 though at different times. So, there is a difference between saying plus plus ptr

നിങ്ങൾക്ക് രണ്ട് പോയിന്ററുകൾ (pointer) കുറയ്ക്കാനും കഴിയും. ഈ മൊഡ്യൂളിന്റെ (module)

and ptr plus plus, plus plus ptr is called the pre increment operator. So, it means increment

അവസാനം ഒരു ചെറിയ ഉദാഹരണം കാണും, നിങ്ങൾക്ക് അസൈൻ (assign) ചെയ്യാനും താരതമ്യം ചെയ്യാനും

the value of ptr and then use it and ptr plus plus is post increment operator. Use the current

കഴിയും. നിങ്ങൾക്ക് പോയിന്ററുകൾ (pointer) ഉപയോഗിച്ച് ചെയ്യാൻ കഴിയുന്ന നിരവധി കാര്യങ്ങളാണിവ. നമുക്ക് ഓരോന്നും കാണാം; ആദ്യത്തേത്

value of ptr and then later increment the value of ptr.

ഇൻക്രിമെന്റ് / ഡി ക്രിമെന്റ് (increment/decrement). P എന്നത് ടൈപ്പ് (type) T യിലേക്കുള്ള ഒരു

But, I want you to do this little exercise. So, change the line B. So, if you look at

പോയിന്റർ (pointer) ആണെങ്കിൽ, സി (C) യിൽ ടി (T) എന്ന് വിളിക്കുന്ന ഒരു ഡാറ്റാ (data) തരവുമില്ല.

line B, it saying contents in address ptr plus percentage d is i comma star of ptr plus i. So, change that to star ptr plus plus and run it again and once more change that line

ഞാൻ ഇത് ഒരു ടെംപ്ലേറ്റായി (template) ഉപയോഗിക്കുന്നു. നമുക്ക് ടി (T) എന്ന് വിളിക്കുന്ന ഒരു ഡാറ്റാ (data) തരം ഉണ്ട്, പി (p) എന്നത് ടി (T) യിലേക്കുള്ള ഒരു പോയിന്ററാണ്., ടി (T) ഒരു ഇന്റിജെർ

(integer), കാരക്ടർ (character) ഫ്ലോട്ടിംഗ് പോയിന്റ് (floating point) ആകാം, അത് എന്തും ആകാം പി ++ sizeof(T) ഘട്ടങ്ങളിലൂടെ

to star plus plus ptr and run it once more. So, you take this piece of program which is

പി (p) യുടെ മൂല്യം വർദ്ധിപ്പിക്കും. ഞാൻ ഇതിനകം ഇത് സൂചിപ്പിച്ചിട്ടുണ്ട്, നിങ്ങൾ സൈസ് ഓഫ്

in this slide, but make changes to line B, using either this line or this line, compile

(sizeof) ഡാറ്റ (data) തരം എന്ന് പറഞ്ഞാൽ, അത് നിങ്ങളോട് പറയുന്നു, ഡാറ്റ (data) തരം സംഭരിക്കുന്നതിന്

and run it and try and reason why, whatever is happening, why it is happening? So, try

ആവശ്യമായ ബൈറ്റുകളുടെ (byte) എണ്ണം എന്താണ്. നിങ്ങൾ p ++ ചെയ്യുമ്പോൾ, അടുത്ത ബൈറ്റിലേക്ക് (byte) പോയിന്റു (point) ചെയ്യുന്നു പി വർദ്ധിപ്പിക്കുകയല്ല,

a reason about that. So, let us move forward, there is another useful thing in C, which

അത് ഡാറ്റാ (data) തരം ടി (T) യുടെ അടുത്ത

is called the sizeof operator.

സാധുവായ ഘടകത്തിലേക്ക് പി പോയിന്റ് (point) ചെയ്യാൻ

So, it is not directly relevant to pointers, but this is something that I want to talk

പോകുന്നു. എന്റെ സംഖ്യ യഥാർത്ഥത്തിൽ

about now and again use this sizeof operator to explain a few things later. So, in this

4 ബൈറ്റുകളാണെന്ന് (byte) പറയാം . എനിക്ക് a എന്ന് വിളിക്കുന്ന ഒരു സംഖ്യയുണ്ട്,

program we have three integers called int size, chr size and float size, flt size and

അത് 4 ബൈറ്റുകൾ (byte) ഉൾക്കൊള്ളുന്നുവെന്ന് പറയട്ടെ, ഇത് 5 വലുപ്പത്തിന്റെ ഒരു ശ്രേണിയല്ല. ഞാൻ ഒരു മെമ്മറി (memory) വരയ്ക്കുന്നു,

we are going to do this, int size is size of int, chr size is size of char and flt size

വേരിയബിൾ (variable) a 4 ബൈറ്റുകളിൽ (byte) സംഭരിച്ചിരിക്കുന്നുവെന്ന് നമുക്ക് പറയാം. 100, 101, 102, 103 എന്നീ സ്ഥലങ്ങൾ

is size of float. So, as the name might indicate to you, you are looking at the size of an

നമുക്ക് പറയാം, കൂടാതെ ലൊക്കേഷൻ (location) 104, 105, 106, 107 എന്നിവയാണ് അടുത്ത സെറ്റ് (set) ലൊക്കേഷനുകൾ

integer or size of a character and size of a floating point and so, on.

(location). Ptr a യിലേക്ക് പോയിന്റ് (point) ചെയ്തെങ്കിൽ,

What is it mean by asking for sizeof an integer? So, integer is actually a set of values and

നിങ്ങൾ ptr++ ചെയ്താൽ, ptr 101 ലേക്ക് പോയിന്റ് (point) ചെയ്യില്ല, കാരണം ptr ഡാറ്റാ (data) തരം സൂചിപ്പിക്കുന്നത് പൂർണ്ണസംഖ്യയാണ്, അടുത്ത സാധുവായ സംഖ്യ 100 ൽ നിന്ന് നാല് ഘട്ടങ്ങൾ അകലെയാണ്. Ptr++ സ്ഥാനം

this can be. So, if you go and look at the real world, the set of integers is unbounded

104 ലെ പൂർണ്ണസംഖ്യയിലേക്ക് പോയിന്റു (point) ചെയ്യും . നമുക്ക് സ്ലൈഡിലേക്ക്

in size. So, you have all the way from minus infinity to plus infinity, it is not something

(slide) മടങ്ങാം. ഡാറ്റാ (data) തരം T tab [n ] ഉണ്ട് , T *p ഡിക്ലറേഷൻ ഉണ്ട്. നിങ്ങൾക്ക് ടി പകരം

that a C language supports to. So, you cannot store every possible integer that is out there.

ഇന്റ് (int), ചാർ (char), ഫ്ലോട്ട് (float) എന്നിവ ഉപയോഗിച്ച് ആവശ്യമുള്ളത് മാറ്റാം. ടി (T) ഒരു സാധുവായ

C instead restricts it to be at least 4 bytes in size.

ഡാറ്റ (data) തരമല്ല, നമുക്ക് int i= 4 എന്ന്

So, if you say sizeof int, it is actually giving you the number of bytes that is use

പറയാം, ഞാൻ p =&tab [i ] ചെയ്താൽ i 4 ആണ്. &tab [4] എന്നെ ടാബിലെ

to represent an integer. Similarly, sizeof character will give you the number of bytes

(tab) നാലാമത്തേതിലേക്ക് നയിക്കും. അതിനാൽ, എൻട്രി (entry) ആരംഭം 0 എന്ന് ഓർക്കുക. നമ്മൾ

required to store a character and sizeof float is going to give you number of bytes for storing

സംസാരിക്കുന്നത് 0, 1, 2, 3, 4 എന്നിവയെക്കുറിച്ചാണ്. 0 മുതൽ ആരംഭിക്കുന്ന നാലാമത്തെ എൻ‌ട്രിയാണ് (entry) ith എൻ‌ട്രി (entry), p ടാബിലെ (tab) നാലാമത്തെ

a floating pointing number and so, on. So, these things can vary across different machines

എൻ‌ട്രിയിലേക്ക് (entry) പോയിന്റു (point) ചെയ്യാൻ പോകുന്നു, നിങ്ങൾ p ++ ചെയ്യുമ്പോൾ, അത്

and so, on. But, the basic point is whenever you do sizeof int, for the machine that you

ടാബിലെ (tab) അടുത്ത എൻ‌ട്രിയിലേക്ക് (entry) പോയിന്റു (point) ചെയ്യാൻ ആരംഭിക്കുന്നു. ഇത്

are running on, it will tell you how many bytes are required to store an integer.

പോയിന്റർ (pointer) ഗണിതത്തിന്റെ ഒരു ഉദാഹരണമാണ്, നിങ്ങൾ അതിൽ പോയിന്ററും (pointer) പൂർണ്ണ സംഖ്യകളും

So, in most modern machines the sizeof integer is either 4 bytes or it can be even 8 bytes.

മിക്സ് (mix) ചെയ്യുന്നു. നിങ്ങൾക്ക് പോയിന്ററുകളിൽ (pointer) നിന്ന് ചേർക്കാനും കുറയ്ക്കാനും കഴിയും, വർദ്ധനവും കുറവും ചെയ്യേണ്ടതില്ല, നിങ്ങൾക്ക് ചേർക്കാനും

So, let us look at a few things related to pointer arithmetic. So, I am going back to

കഴിയും. ഈ ഉദാഹരണത്തിൽ ടാബിന്റെ (tab) 0-ാം സ്ഥാനത്ത്

pointer arithmetic, you can do a lot of things with pointers and arithmetic related to pointers.

p പോയിന്റ് (point) ചെയ്തു, അതിൽ 5 ചേർക്കുന്നു, അതായത് ഇത് tab [5] ലേക്ക് പോയിന്റു (point) ചെയ്യാൻ

So, you can assign between pointers of the same type, you can do addition and subtraction

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

between a pointer and an integer. We already saw this example, we did ptr plus 1 and ptr

(array) അംഗങ്ങളിലേക്ക് വിരൽ ചൂണ്ടുന്നുവെങ്കിൽ, നിങ്ങൾക്ക് ==, !=, <, എന്നിങ്ങനെയുള്ള കാര്യങ്ങൾ ചെയ്യാൻ

plus plus and so, on. So, ptr was of type pointer and plus 1 is actually adding an integer

കഴിയും. എനിക്ക് ഒരു പൂർണ്ണ സംഖ്യയുണ്ടെന്ന് പറയാം. ഈ സാഹചര്യത്തിൽ ഞാൻ ഒരു അറേ (array) വരയ്ക്കുന്നു,

1 to ptr. So, however, C allows you to do that, you can compare two pointers that point

മെമ്മറി (memory) അല്ല, ഞാൻ ഒരു അറേ (array) വരയ്ക്കുന്നു. നമുക്ക് പറയാം, എനിക്ക് ഒരു അറേ ഉണ്ട് (array),

to elements of the same array, you can even subtract two pointers. We will see a small

ഇത് a[0] ആണെന്നും ഇത് a[4] ആണെന്നും പറയാം.

example at the end of this module and you can assign and compare. So, these are several things that you can do with pointers.

ഞാൻ ഈ സ്ഥലത്ത് പി പോയിന്റ് (point) ഉണ്ടാക്കുകയും ഈ സ്ഥലത്ത് പോയിന്റർ (pointer) q പോയിന്റ് (point)

Let us see each one, one after the other; the first one is increment decrement. So,

ഉണ്ടാക്കുകയും ചെയ്താൽ, എനിക്ക് ചോദിക്കാം p<q ആണോ എന്ന്. അതിന്റെ അർത്ഥം p

if p is a pointer to type T. So, there is actually no data type called T in C. So, I am using this as a template. Let us say, I have a data type called T and p is a pointer

ഒരു സ്ഥാനത്തേക്ക് ചൂണ്ടിക്കാണിക്കുന്നു, അത് q സൂചിപ്പിക്കുന്നതിനേക്കാൾ മുമ്പുള്ള അറേയിൽ (array) ഉണ്ട്, ഈ സാഹചര്യത്തിൽ p q യേക്കാൾ കുറവാണ്.

to T. So, T could be an integer, character, floating point, it could be anything p plus

p എന്നത് q ന് തുല്യമല്ല., ഈ സാഹചര്യത്തിൽ p

plus will increases the value of p by sizeof T steps.

യഥാർത്ഥത്തിൽ q ന് തുല്യമല്ല, p 0 സ്ഥാനത്തേക്ക്

So, I already mentioned this, if you say sizeof data type, it tells you, what is the number

വിരൽ ചൂണ്ടുന്നു, q 4 ന്റെ 4 ലേക്ക് വിരൽ ചൂണ്ടുന്നു. അതിനാൽ, p യഥാർത്ഥത്തിൽ q ന്

of bytes required to store the data type. So, when you do p plus plus, it is not incrementing

തുല്യമല്ല. ഒരേ അറേയിലേക്ക് (array) പോയിന്റു (point) ചെയ്യുന്ന പോയിന്ററുകൾ (pointer) നിങ്ങൾക്ക് അർത്ഥപൂർവ്വം

p to point to the next byte, it is going to make p point to the next valid element of

താരതമ്യം ചെയ്യാം. നിങ്ങൾക്ക് ഇത് ചോദിക്കാൻ കഴിയും, ഇത് മറ്റ് പോയിന്ററിനേക്കാൾ (pointer) മുമ്പുള്ളതാണോ, ഇത് മറ്റ് പോയിന്ററിനേക്കാൾ

the data type T. So, let us say my integer is actually 4 bytes. So, I have an integer

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

called a and let us say, it is occupying 4 bytes, this is not an array of size 5. So, I am drawing a memory footprint and let us say variable a is stored in 4 bytes. Let us say a location 100, 101, 102 and 103 and let us say location 104, 105, 106 and 107

കഴിയും, കൂടാതെ അസമത്വത്തിന് പൂജ്യവുമായി താരതമ്യം ചെയ്യാനും കഴിയും, p നൾ (null) ആണോ ? p എന്നത് a [ 0] ത്തിലേക്ക് പോയിന്റ് (point) ചെയ്യുന്നുവെന്നും p ==null ആണോ എന്നും ചോദിക്കാമെന്നും പറയാം. ഞാൻ ഈ ചോദ്യം

ചോദിച്ചാൽ, ഇത് യഥാർത്ഥത്തിൽ തെറ്റായി വിലയിരുത്തും, കാരണം p യഥാർത്ഥത്തിൽ a [0] ലേക്ക് പോയിന്റ്

are the next set of locations. If ptr is made to point a and if you do ptr plus plus, ptr

(point) ചെയ്യുന്നു. നിങ്ങൾക്ക് ഇത്തരത്തിലുള്ള താരതമ്യങ്ങൾ ചെയ്യാൻ കഴിയും. ഇൻക്രിമെന്റ് / ഡി ക്രിമെന്റ് (increment/decrement) ഒരു സംഖ്യ ചേർക്കുന്നതും അല്ലെങ്കിൽ ഒരു പോയിന്ററിൽ

(pointer) നിന്ന് ഒരു സംഖ്യ കുറയ്ക്കുന്നതും

will not point to 101, because the data type ptr is pointing to is integer, the next valid

കണ്ടു. പോയിന്ററുകളെക്കുറിച്ചുള്ള (pointer) അവസാനത്തെ മനോഹരമായ ഒരു കാര്യം, നിങ്ങൾക്ക് പോയിന്ററുകൾ (pointer) കുറയ്ക്കാനും കഴിയും. അതിനാൽ, ഇവിടെ അത്

integer is four steps away from 100. So, ptr plus plus will make it point to the integer

കാണിക്കാൻ ശ്രമിക്കുന്ന ഒരു ചെറിയ കോഡ് (code) ഇവിടെ ചെയ്യുന്നു. ഇത് ചെറുതായി ലോഡ് (load) ചെയ്‌തു, ഇത് എന്താണ് ചെയ്യുന്നതെന്ന്

at location 104. So, let us look go back to the slide. So, if we have data type T, tab of n and if you have a declaration T star p. So, you can substitute

നമുക്ക് നോക്കാം. ഇവിടെ രണ്ട് പോയിന്ററുകൾ (pointer) ഉണ്ട്, ഒന്ന് s എന്നും മറ്റൊന്ന് p എന്നും വിളിക്കുന്നു, ഇത് യഥാർത്ഥത്തിൽ ‘strlen’ അഥവാ സ്ട്രിംഗ് ലെങ്ത് (string length) എന്ന്

T with int, char, float whatever you want. So, T itself is not a valid data type and

വിളിക്കുന്ന ഒരു ഫംഗ്ഷനാണ്. ഒരു സ്ട്രിംഗ് (string) നൽകിയാൽ, സ്ട്രിംഗിന്റെ (string) നീളം എന്താണ് അത് കണ്ടെത്താൻ ശ്രമിക്കുന്നു.

let us say int i equals 4, if I do p equals ampersand of tab of i, so, i is 4. So, ampersand

സിയിലെ ഒരു സ്ട്രിംഗ് (string) എന്താണെന്ന് നമുക്ക് നോക്കാം. എങ്ങനെയെങ്കിലും ഞാൻ ഇത് പിന്നീട് വിശദമായി ചെയ്യും, പക്ഷേ സി (C ) യിലെ ഒരു സ്ട്രിംഗ് (string) യഥാർത്ഥത്തിൽ

of tab of 4 will make me point to the 4th entry in tab. So, remember the entry start at 0. So, we are talking about 0th, 1th, 2th, 3th and 4th.

കാരക്ടറുകളുടെ (character) ഒരു ശ്രേണി മാത്രമാണ്, അതിനുശേഷം ബാക്ക്സ്ലാഷ് 0 (\0)എന്ന പ്രത്യേക കാരക്ടർ (character). നമുക്ക് പറയാം ഹലോ (hello) എന്ന് വിളിക്കുന്ന ഒരു സ്ട്രിംഗ് (string) ഉണ്ട്,

So, the ith entry is the 4th entry, starting from 0. So, p is going to point at the 4th

അത് ഈ ഫോമിൽ (form) സൂക്ഷിക്കും, ഇത് അക്ഷരം o ആണ്, അതിനു മുകളിൽ സി (C ) യിൽ ബാക്ക്‌സ്ലാഷ് 0 (\0) എന്ന് വിളിക്കുന്ന ഒരു പ്രത്യേക കാരക്ടർ

entry in tab and when you do p plus plus, it actually starts pointing at the next entry

(character) ഉണ്ട് . അതിനാൽ, ഈ കേസ് (case) യഥാർത്ഥത്തിൽ 0 ആണ് അല്ലെങ്കിൽ അതിനെ നൾ കാരക്ടർ

in tab. So, this is an example of pointer arithmetic, where you mix pointer and integer

(nul character) എന്ന് വിളിക്കുന്നു. ഹലോ (hello) എന്ന് വിളിക്കുന്ന ഒരു സ്ട്രിംഗ് (string), അതിന്റെ നീളം 5 ആയിരിക്കണം, പക്ഷേ വാസ്തവത്തിൽ

operations on it.

ഇത് 6 ബൈറ്റുകൾ (byte) എടുക്കും. ഈ സ്ട്രിംഗിന്റെ

You can also do add and subtract from pointers, you do not have to do just increment and decrement,

(string) ദൈർഘ്യം എത്രയാണെന്ന് കണ്ടെത്താൻ ഞാൻ ആഗ്രഹിക്കുന്നു.

you can also add. So, in this example what we have done is, we have made p point at the

എനിക്ക് സ്‌ട്രിംഗിന്റെ (string) 0-ാം സ്ഥാനത്ത് നിന്ന് പരിശോധിക്കുന്നത് തുടരാം, ഒന്നിനുപുറകെ ഒന്നായി എനിക്ക് ഒരു കാരക്ടർ (character)

0th location of tab and we are adding 5 to it, which means it will start pointing to tab of 5.

പരിശോധിക്കുന്നത് തുടരാം, കൂടാതെ ബാക്ക്‌സ്ലാഷ് 0 (\0) എന്ന് വിളിക്കുന്ന ഈ പ്രത്യേക കാരക്ടറി നായി (character) ഞാൻ നോക്കും. ഞാൻ ഒരു ബാക്ക്‌സ്ലാഷ്

You can compare pointers, if p and q are pointers of the same, if they are pointing to members

0 (\0) കാണുന്ന നിമിഷം, ഇത് ഇതാണ് സ്ട്രിംഗിന്റെ (string) അവസാനവും ഇത് സി (C ) യിൽ ഉപയോഗിക്കുന്ന

of the same array, then you can do things like equal to equal to, not equal to, less

കൺവെൻഷനുമാണ് (convention). ഞാൻ പറഞ്ഞതുപോലെ ഇത് പിന്നീട് കൂടുതൽ വിശദമായി പിന്നീട്

than and so, on. So, let us say I have an integer array and. So, in this case I am drawing

കാണും, പക്ഷേ ഇപ്പോൾ നമുക്ക് ഈ ഉദാഹരണം നോക്കാം. സ്ട്രിംഗിന്റെ (string) നീളം എന്താണെന്ന്

an array, not memory, I am drawing an array. Let us say, I have an array a and let us say

കണ്ടെത്താൻ ഞാൻ ആഗ്രഹിക്കുന്നു. ഞാൻ ഒരു ചെറിയ ഫംഗ്ഷൻ (function) എഴുതിയിട്ടുണ്ട്. ക്യാരക്ടർ *എസ്, ക്യാരക്ടർ

this is a of 0 and this is a of 4. If I make p point at this location and if I make pointer q point at this location, then I can actually ask the question is p less than q. So, the meaning of that is p pointing to a location, that is earlier in the array than

*പി (char *s, char *p). ഈ ഘട്ടത്തിൽ p നെ s ലേക്ക് ഇനിഷ്യലായ്‌സ്

what q is pointing to, in this case p is less than q is actually true. So, you can also do is p not equal to q. So, in this case p is actually not equal to q, p is pointing to the 0th location, q is pointing to a of 4. So, p is actually not equal to q. So, you

(initialise) ചെയ്യുന്നു . അതിനാൽ, നിങ്ങൾ ഇവിടെ

can meaningfully compare pointers which are pointing to the same array. You can ask is this is the same, is this earlier than the other pointer, is it later than the other pointer and so, on. So, you can make pointers point at different

കാണുന്ന കാരക്ടർ അറേയിലേക്കുള്ള

locations in an array. You can ask the questions, whether one pointer is lesser than the other and so, on and we can also compare it for inequality with zero, you can ask the question, is p equal to null? So, let us say p is pointing to a of 0 and I can ask the question, if p

(character array) പോയിന്ററാണ് (pointer) s. s ഒരു കാരക്ടർ

equal to equal to null? If I ask this question, this will actually evaluate to false, because p is actually pointing to a of 0. So, you can do comparisons of this kind. So, we looked at increment decrement and adding an integer or subtracting an integer from a pointer. One final beautiful thing about pointers is that, you can also do subtraction

അറേയിലേക്ക് പോയിന്റ് ചെയ്യുന്നു (character array) , character* p = s. s ന്റെ 0 മത്തെ സ്ഥാനത്തും p പോയിന്റ് ചെയ്യുന്നു . ദൈർഘ്യം കണ്ടെത്താൻ

of pointers. So, does a small piece of code here which actually tries to show that. So,

this one is slightly loaded, but let us see what it is doing. So, there are two pointers

ആഗ്രഹിക്കുന്ന സ്ട്രിംഗാണ് (string) s.

here, one called s and one called p and this is actually a function which is called string length ‘strlen’. So, given a string it tries to find out, what

p പോയിന്റ് (point) ചെയ്യുന്ന മെമ്മറി ലൊക്കേഷന്റെ (memory location) ഉള്ളടക്കങ്ങൾ ബാക്ക്‌സ്ലാഷ് 0

is the length of the string? So, let us see what a string is in C. I will anyway do this

(backslash \0) സജ്ജമാക്കിയിട്ടുണ്ടോ ഇല്ലയോ എന്ന് പരിശോധിക്കാൻ

in more detail later, but a string in C is actually just a sequence of characters followed

ഇവിടെ വൈൽ ലൂപ്പ് (while loop) ഉണ്ട്. ഒരു പ്രത്യേക

by a special character called backslash 0. For instants, let us say I have a string called hello, it will be stored in this form, you have h e l l o. So, this is letter o and on top of that in C, there is a special character called backslash 0. So, this case is actually 0 or what is called the null character. So, a string called hello, it supposed to

കാരക്ടർ (character) ബാക്ക്‌സ്ലാഷ് 0 (backslash \0) ഉണ്ട്, ഞാൻ സ്ഥാനം h ൽ നിന്ന് ആരംഭിക്കാൻ പോകുന്നു.

be of length 5, but in reality it actually takes 6 bytes. So, let us I want to find out what is the length of this string? So, I can keep checking starting from the 0th location

of the string, I can keep checking for one character after the other and I will look for this special character called backslash 0. The moment I see a backslash 0, it means that this is the end of the string and this is the convention used in C. So, like I said we again see this in more detail later, but as of now let us look at

h സംഭരിച്ചിരിക്കുന്നിടത്ത്, ഞാൻ ഒരു ബാക്ക്‌സ്ലാഷ്

this example. So, let us I want to find out what the length of the string is. So, I have written a small function which does that. So, character star s and character star p. So, at this point p is initialized to s. So, s is a pointer to a character array that is what you see here. So, s is pointing to a character array and character star p equals

0 (backslash \0) കാണുന്നത് വരെ. തുടക്കത്തിൽ

s. So, p also points at the 0th location of s. So, s is the string for which we want to find out the length. So, there is a while loop here that keeps

checking, if the contents of the memory location pointed by p is set backslash 0 or not. So,

p h ലേക്ക് പോയിന്റ് (point) ചെയ്യുന്നു , *p ബാക്ക്‌സ്ലാഷ് 0

there is a special character backslash 0, I am going to start from location h. So, where h is stored, all the way till I see a backslash 0. So, initially p is pointing at h and star

(backslash \0) ന് തുല്യമല്ല, ഒരു p++ ചെയ്യുന്നു. p ഇവിടെ ചൂണ്ടിക്കാണിക്കാൻ തുടങ്ങും.

p is not equal to backslash 0, we do a p plus plus. So, p will start pointing here.

p ഇതിനകം ഒരു സ്ഥലത്തേക്ക് നീങ്ങി, അത് s[1] e എന്നിടത്ത്

So, p has already moved by one location, it has started pointing at s of 1, s of 1 is e and it is not backslash 0. So, the while loop will continue and start pointing at l and this will keep happening and it will stop, when p points at backslash 0. So, let us assume

പോയിന്റുചെയ്യാൻ തുടങ്ങി, അത് ബാക്ക്സ്ലാഷ് 0 (backslash 0 -\0) അല്ല. അതേസമയം ലൂപ്പ് (loop) തുടരുകയും l ലേക്ക് പോയിന്റു (point) ചെയ്യാൻ തുടങ്ങുകയും ഇത് സംഭവിക്കുകയും ചെയ്യും p ബാക്ക്‌സ്ലാഷ്

0 (backslash 0 -\0) ൽ പോയിന്റുചെയ്യുമ്പോൾ നിർത്തും. ഇത് 100 സ്ഥാനത്താണെന്നും

that this is at location 100, this is at 101 and so, on, this will be at location 105.

ഇത് 101 ആണെന്നും ഇത് 105 ലൊക്കേഷനായിരിക്കുമെന്നും നമുക്ക് അനുമാനിക്കാം. അതേസമയം ലൂപ്പ് നിർത്തുമ്പോൾ,

So, when the while loop will stop, when star p is equal to 0. When the star p equal to

*p 0 ന് തുല്യമാണ്. *p 0 ന് തുല്യമാകുമ്പോൾ? P 105 ആകുമ്പോൾ, *p ബാക്ക്‌സ്ലാഷ് 0 (backslash 0 -\0) ആണെന്നും

0? When p is 105, star p is backslash 0 and which means when p equals 105, the loop will stop. So, at that point, if you go and ask for p minus s. So, p is 105 and s is memory location 100, 105 minus 100 is 5, that actually gives

അതിനർത്ഥം p 105 ന് തുല്യമാകുമ്പോൾ ലൂപ്പ് (loop) നിർത്തും ആ സമയത്ത്, നിങ്ങൾ പോയി p- ചോദിച്ചാൽ. p 105 ഉം s മെമ്മറി ലൊക്കേഷൻ (memory location) 100 ഉം 105-100 5 ഉം ആണ്, ഇത് യഥാർത്ഥത്തിൽ ഹലോയുടെ (hello) ശരിയായ

us the correct length of hello. So, this is a very neat and beautiful trick to show with

ദൈർഘ്യം നൽകുന്നു. പോയിന്റർ അരിത്മെറ്റിക് (pointer arithmetic) ഉപയോഗിച്ച് കാണിക്കാൻ ഇത് വളരെ

pointer arithmetic. So, let us not worry about, what this written statement is and what is this strange looking int strlen and so, on is later. But, as of now I just want you to pay attention to the while loop. So, it iterated over the elements of s and

വൃത്തിയും വെടിപ്പുമുള്ള തന്ത്രമാണ്. ഈ സ്റ്റേറ്റ്മെന്റ് (statement) എന്താണെന്നും ഈ വിചിത്രമായി കാണപ്പെടുന്ന int strlen എന്താണെന്നും ഇപ്പോൾ നോക്കേണ്ടതില്ല. ഇപ്പോൾ നിങ്ങൾ വൈൽ ലൂപ്പിന് (while loop) ശ്രദ്ധ

നൽകുക . ഇത് s ന്റെ ഘടകങ്ങളെക്കാൾ

it is stopped at backslash 0 at that point, p got value 105 and if you do p minus s, it actually gives you 105 minus 100 which is 5. So, when you do arithmetic over pointers,

ആവർത്തനം ചെയ്യുന്നു, അത് ബാക്ക്‌സ്ലാഷ് 0 ൽ നിർത്തുന്നു, p ന് മൂല്യം 105 ലഭിച്ചു, നിങ്ങൾ p -s ചെയ്താൽ, അത് നിങ്ങൾക്ക് 105-

if you do subtraction of pointers, you actually get an integer back and this is something

100 നൽകുന്നു, അതായത് 5 ആണ്. നിങ്ങൾ നിങ്ങൾ

that is very handy. We will see use cases for this in a lot more detail, later. So,

പോയിൻററുകൾ‌ (pointer) കുറയ്‌ക്കുകയാണെങ്കിൽ‌, നിങ്ങൾ‌ക്ക് യഥാർത്ഥത്തിൽ‌ ഒരു സംഖ്യ തിരികെ ലഭിക്കും, ഇത് വളരെ സൗ കര്യപ്രദമാണ്.

we have now come to the end of this module. In the subsequent modules, we will see how

ഇതിനായുള്ള ഉപയോഗ കേസുകൾ (case) പിന്നീട് കൂടുതൽ വിശദമായി കാണും. ഇപ്പോൾ ഈ മൊഡ്യൂളിന്റെ

to use pointers for manipulating arrays and we will also see how pointers are useful in

(module) അവസാനത്തിലെത്തി. തുടർന്നുള്ള മൊഡ്യൂളുകളിൽ (module) അറേകൾ (array) കൈകാര്യം ചെയ്യുന്നതിന് പോയിന്ററുകൾ (pointer) എങ്ങനെ ഉപയോഗിക്കാമെന്ന് കാണും കൂടാതെ ഫംഗ്ഷനുകൾ

the context of order called functions. So, we will start looking at functions and

(function) എന്ന് വിളിക്കുന്ന ക്രമത്തിന്റെ പശ്ചാത്തലത്തിൽ

when we visit functions, we will revisit how pointers are handled, when we pass them on

പോയിന്ററുകൾ (pointer) എങ്ങനെ ഉപയോഗപ്രദമാകുമെന്ന്കാണും. ഫംഗ്ഷനുകൾ നോക്കാൻ തുടങ്ങും, ഫംഗ്ഷനുകൾ സന്ദർശിക്കുമ്പോൾ, പോയിന്ററുകൾ ഫംഗ്ഷനുകളിലേക്ക് കൈമാറുമ്പോൾ അവ എങ്ങനെ കൈകാര്യം ചെയ്യുമെന്ന്

to functions. Thank you, very much.

വീണ്ടും സന്ദർശിക്കും,.