More on pointers Programming, Data Structures and Algorithms English Malayalam

More on pointersYouTube↗ IA↗(long shot)
People & Blogs 1.5K views 4 likes 0 dislikes 30 Jan 2018

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

In this module, we will see a little bit more of details on pointers itself. So, let us go back to the code that we saw earlier. So, we have int k equals to 38, int star p and p is ampersand of k, star p equals 5.

ഈ മോഡ്യൂളിൽ (module) പോയിന്ററുകളെ (pointer) കുറിച്ചുള്ള കൂടുതൽ വിശദാംശങ്ങൾ കാണും. നമ്മൾ മുമ്പ് കണ്ട കോഡിലേക്ക് (code) മടങ്ങാം. നമുക്ക് int k =38 ന്, int * p p =& k എന്നിവയുണ്ട്.

അതിനാൽ, നേരത്തെ പറഞ്ഞ ഒരു കാര്യം നക്ഷത്രചിഹ്നത്തിന്റെ (*) ഈ സങ്കൽപ്പമാണ്, ഇത് എന്തിനുവേണ്ടിയാണ് ഉപയോഗിക്കുന്നത്. ഇത് രണ്ട് സ്ഥലങ്ങളിൽ ഉപയോഗിച്ചിരിക്കുന്നതായി

So, one thing that I did not emphasize earlier is this notion of asterisk (*), what is it

നിങ്ങൾക്ക് കാണാൻ കഴിയും, ഒരു സ്ഥലത്ത് int *p എന്നും മറ്റൊന്ന് *p=5 ആണ്. അവ പോയിന്ററുകളുമായി (pointer) ബന്ധപ്പെട്ടിരിക്കുന്നു, ഈ നക്ഷത്രചിഹ്നം

used for.

രണ്ട് അർത്ഥങ്ങളിൽ ഉപയോഗിക്കുന്നു.

So, you can see that it is used in two places, in one place as int star p and the other place;

ആദ്യമായി നിങ്ങൾ ഒരു പോയിന്റർ (pointer) പ്രഖ്യാപിക്കുമ്പോൾ, നിങ്ങൾ int *p എന്നും

we have star p equals 5.

p ഇന്റിജെറിനെ (integer) പോയിന്റ് (point) ചെയ്യുന്ന

So, they are related to pointers, this asterisk symbol is used in two connotations.

ഒരു പോയിന്റർ വേരിയബിൾ (pointer variable) ആണെന്നും ആണ്. പിന്നീട് നിങ്ങൾ *p = 5 ന് തുല്യമാണെന്ന് പറയുമ്പോൾ, അർത്ഥം അല്പം വ്യത്യസ്തമായിരിക്കും.,

First time when you declare a pointer, you say int star p and that point you are saying

പോയിന്റർ ഡീഫറൻസിംഗ് (pointer dereferencing) എന്ന് വിളിക്കുന്നതാണ് നിങ്ങൾ ചെയ്യുന്നത്. ഈ സമയത്ത് ഇത് വേരിയബിൾ

that p is a variable of type pointer to integer.

(variable) p അല്ലെങ്കിൽ അതുപോലുള്ള എന്തിനും സ്ഥലം അനുവദിക്കാൻ കംപൈലറോട് (compiler) പറയുന്നില്ല. ഇവിടെ, യഥാർത്ഥത്തിൽ നമ്മൾ p ന്റെ r മൂല്യം

And later when you say star p equals to 5, the meaning is slightly different.

കൈകാര്യം ചെയ്യുന്നു. കോഴ്സിലും (course) മറ്റിടങ്ങളിലും നിങ്ങൾ കാണുന്ന ഒരു ചെറിയ കാര്യം, നമ്മൾ

What you are doing is, you are doing what is called dereferencing the pointer.

സാധാരണയായി പറയുന്നത് p ലേക്ക് പോയിന്റ് (point) ചെയ്യുന്നു എന്നാണ്. ഈ സാഹചര്യത്തിൽ p=&k.

So, at this point this is not telling the compiler to allocate space for the variable

p=&k എന്ന ഈ സാങ്കേതിക പദം ഉപയോഗിക്കുന്നതിനുപകരം, നമ്മൾ സാധാരണയായി പറയുന്നത് p k ലേക്ക്

p or anything like that.

പോയിന്റ് (point) ചെയ്യുന്നു എന്നാണ്.

Here, actually we are dealing with the r value of p.

നമുക്ക് ഒരു ഡീഫെറൻസിംഗ് ഓപ്പറേറ്റർ (dereferencing

So, one small thing that you will see in the course as well as elsewhere is that, we usually

operator) നോക്കാം. ഇത് നക്ഷത്രചിഹ്നമാണ്, * p -=7 എന്ന് നിങ്ങൾ പറയുമ്പോൾ, അത് മൂല്യം

say p is pointing to k.

7 എടുത്ത് p പോയിന്റ് (point) ചെയ്യുന്ന വിലാസത്തിലേക്ക്

So, in this case p is ampersand of k. So, instead of using this technical term, the p equals ampersand of k, we usually say

പകർത്തുന്നു. p k ലേക്ക് പോയിന്റ് (point) ചെയ്യുന്നു വെങ്കിൽ, മുകളിലുള്ള പ്രസ്താവന k യുടെ

that p points to k or p is pointing to k and so, on.

ഉള്ളടക്കത്തെയും 7 ആയി മാറ്റും. കൂടാതെ ഈ ഡീഫെറൻസിംഗ് (dereferencing) ഒരു സാങ്കേതിക പദമാണ് അത് പിന്നീട് പ്രഭാഷണത്തിലും ഉപയോഗിക്കുന്നു.

So, let us look at a dereferencing operator.

നൾ പോയിന്റർ (null pointer) എന്ന് വിളിക്കുന്ന

So, it is the asterisk symbol and when you say star p equals to 7, it takes the value

ഒരു പ്രത്യേക പോയിന്റർ (pointer) ഉണ്ട്, സാധാരണയായി ചില നിർദ്ദിഷ്ട വേരിയബിളിലേക്ക് (variable) പോയിന്റു (point) ചെയ്യാൻ പോയിന്ററുകൾ (pointer) ഉപയോഗിക്കുന്നു.

7 and copies it to the address pointed to by p.

എനിക്ക് int *p ഉണ്ടെങ്കിൽ, p =& k ചെയ്തു p എന്നത്

So, we saw this, if p points to k, then the above statement will actually change the contents

k ലേക്ക് പോയിന്റ് (point) ചെയ്യാൻ തുടങ്ങി. പക്ഷേ, നിങ്ങൾക്ക് പോയിന്റർ (pointer) ഒന്നിലും

of the k also to 7.

പോയിന്റ് (point) ചെയ്യാതെ ഇരിക്കാൻ ആഗ്രഹിക്കുന്ന

And this dereferencing is something that you will see as a technical term that is used

നിരവധി കേസുകളുണ്ട് (case), സി അതിനുള്ള ഒരു പ്രത്യേക മാർഗം നിങ്ങൾക്ക് നൽകുന്നു, അതിനെ നൾ പോയിന്റർ (null pointer) എന്ന് വിളിക്കുന്നു.

later in the lecture also.

അതിനാൽ, അസാധുവായ പോയിന്റർ (pointer) സംബന്ധിച്ച ഒരു പ്രധാന കാര്യം മറ്റൊരു സാധുവായ

There is a special pointer called the null pointer and generally we use pointers to point

പോയിന്റർ ഒരിക്കലും ഒരു നൾ പോയിന്ററിന് (null pointer) തുല്യമായി താരതമ്യം ചെയ്യില്ല. അതിന്റെ അർത്ഥമെന്താണെന്ന് നമുക്ക് നോക്കാം. ആദ്യം സി യിൽ പ്രീഡിഫൈൻഡ് കോൺസ്റ്റന്റ് (predefined

to some specific variable. So, if I have int star p, then I did p equals ampersand k in that case, p started pointing

constant) എന്ന് വിളിക്കുന്ന നൾ (null)ഉണ്ട്. ഇത് <stdio.h> ൽ നിർവചിച്ചിരിക്കുന്നു. printf, scanf എന്നിവ പോലെ,

to k.

ഈ നൾ (null) എന്ന കോൺസ്റ്റന്റും (constant) <stdio.h> ലും നിർവചിച്ചിരിക്കുന്നു.

But, there are several cases where you explicitly want the pointer, not to point at anything

നിങ്ങൾ ഉപയോഗിക്കുന്നതിന് മുമ്പ് ഒരു പോയിന്റർ (pointer) നൾ (null) ആണോ അല്ലയോ എന്ന് പരിശോധിക്കുന്നത്

at all.

നല്ലൊരു പരിശീലനമാണ്. ഡൈനാമിക് മെമ്മറി

And C provides you a special way of doing that and that is called the null pointer.

അലോക്കേഷൻ (dynamic memory allocation) ചെയ്യുമ്പോൾ ഇത് കൂടുതൽ വിശദമായി കാണും. പക്ഷേ, ഇപ്പോൾ ഈ കോഡ് (code) നോക്കാം. നമുക്കുള്ളത്, #include<stdio.h>. int *ip =null. ഇത് പൊതുവെ വളരെ നല്ല പ്രോഗ്രാമിംഗ്

So, one key thing about the null pointer is that no other valid pointer.

(programming) പരിശീലനമായി കണക്കാക്കപ്പെടുന്നു, ടൈപ്പ് ഇൻറിജർ പോയിന്ററിന്റെ (integer pointer) ഒരു പോയിന്റർ

So, by that I mean, no other pointer that is actually storing some value or which is

വേരിയബിൾ (pointer variable) വേണം എന്നും . പേര് ip എന്നും പോയിന്റർ (pointer) ഇന്റജെറിന്റെ (integer) ആണെന്നും പറയാം. ഇത് സാധുവായ ഏതെങ്കിലും

going to get point, which is an address of a variable and so, on, will ever compare equal

സ്ഥലത്തേക്ക് പോയിന്റു (point) ചെയ്യുന്നില്ല. അതിനാൽ, നിങ്ങൾ ഇത് ചെയ്യുകയാണെങ്കിൽ, അജ്ഞാതമായ ഒരു സ്ഥലത്തേക്ക് പോയിന്റു (point) ചെയ്യുന്ന

to a null pointer.

പ്രശ്‌നത്തിലും ഈ അജ്ഞാത സ്ഥാനത്ത്

So, let us see what it means.

എന്താണ് സംഭവിക്കുന്നതെന്നും നോക്കേണ്ടി വരില്ല

So, first of all C gives something called a predefined constant called null and this

. അതിനാൽ, നൾ ഉണ്ടെങ്കിൽ, ഇത് സാധുവായ ലൊക്കേഷനല്ലെന്നും (location) നിങ്ങൾ തിരികെ വന്ന് പിന്നീട് അത് മാറ്റുമെന്നും അർത്ഥമാക്കുന്നു. നിങ്ങൾക്ക് പിന്നീട് ip ഏതെങ്കിലും അഡ്രസിലേക്ക്

is defined in stdio dot h <stdio.h>.

(address) കൊടുക്കാൻ കഴിയും. ഇതിനെക്കുറിച്ച്

So, just like printf and scanf, this constant null is also defined in stdio dot h <stdio.h>.

ഞാൻ നേരത്തെ സംസാരിച്ചിരുന്നു. if (ip !=null) printf *ip or if (ip) printf *ip ഉണ്ട്. ഇത് ip നൾ ആണോ അല്ലയോ എന്ന് പരിശോധിക്കുന്നു.

So, generally it is a good practice to check whether a pointer is null or not, before you

ഇത് നൾ ആയി ഇനിഷ്യലായ്സ് (initialize) ചെയ്തു. ഈ ഘട്ടത്തിൽ ip നൾ (null) അല്ലെന്നും ഇവിടെ സാധുവായ ഒരു

use it.

അസൈൻമെന്റ് ഉണ്ടെന്നും പറയാം.

And we will see this in lot more detail, when you do what is called dynamic memory allocation.

സാധുവായ അസൈൻ‌മെന്റ് (assignment) ഇല്ലെങ്കിൽ‌, ip ഇപ്പോഴും നൾ (null) ആയി തുടരും, മാത്രമല്ല

But, let us look at this code for right now.

നിങ്ങൾ‌ മൂല്യം അച്ചടിക്കുകയുമില്ല. ഇത് സാധാരണയായി പ്രായോഗികമായി ചെയ്യുന്ന ഒരു പരിശോധനയാണ്. ഡൈനാമിക് മെമ്മറി

So, what we have is, we have hash include stdio dot h #include <stdio.h>. and we have

അലോക്കേഷൻ (dynamic memory allocation) നോക്കുമ്പോൾ ഇത് എങ്ങനെ ഉപയോഗപ്രദമാകുമെന്ന് വീണ്ടും കാണാം. ഇത് ഇതുവരെ ചെയ്തിട്ടില്ല, പക്ഷേ ‘malloc’ ചെയ്യുമ്പോൾ ഈ ടെംപ്ലേറ്റ് (template) ഉപയോഗിക്കും.

int star ip equals null.

സി (C) യിൽ ഉള്ള മറ്റൊരു കാര്യം, ഇത് ടൈപ്പ്

So, this is generally considered a very good programming practice, you not only said, you

(type) വോയ്‌ഡ്‌ (void) ആയ ഒരു പോയിന്റർ (pointer) നൽകുന്നു എന്നതാണ്. ഇത് ഡിക്ലയർ (declare)

want a pointer variable of type integer pointer.

ചെയ്യുന്നത് void *vptr എന്നാണ്. കൂടാതെ ഈ വോയ്‌ഡ്‌ പോയിന്റർ (void pointer) യഥാർത്ഥത്തിൽ ഒരു ജനറിക് പോയിന്ററാണ് (generic pointer). അത് കൊണ്ട്

The name is ip and the pointer is of an integer type, you also said here, that it is not pointing

എന്തിനെയും പോയിന്റ് (point) ചെയ്യാൻ കഴിയും. ഇതുവരെ നമ്മൾ ഇന്റിജെർ (integer) കണ്ടു, float *ptr1 എന്നും കൊടുക്കാം. പക്ഷേ, ഈ void * vptr ഒരു ജനറിക്

to any valid location.

പോയിന്ററാണ് (generic pointer).

So, if you do this, then we never run into this problem of ‘ip' pointing at an unknown

നിങ്ങൾക്ക് ഇത് ഒരു ഇന്റിജെറി ലേക്ക് (integer) പോയിന്റു (point) ചെയ്യാൻ കഴിയും, ഒരു ഫ്ലോട്ടിംഗ് പോയിന്റിലേക്ക് (floating point) പോയിന്റു (point) ചെയ്യാൻ കഴിയും,

location and what happens in this unknown location and so, on.

ഒരു കാരക്ടർ (character) പോയിന്റ് (point) ചെയ്യാനാകും

So, the moment you have null, it means that it is not valid location and you will probably

അല്ലെങ്കിൽ അത് ഒരു പോയിന്ററിലേക്ക് (pointer) തന്നെ പോയിന്റ് (point) ചെയ്യാൻ കഴിയും. അതിനാൽ, ഇത് വളരെ എളുപ്പമുള്ള മറ്റൊരു

come back and change it later.

കാര്യമാണ്, ഇത് നിങ്ങൾ ഇപ്പോൾ ശ്രദ്ധിക്കാൻ

So, you may do ip equals address of something later and this is what I was talking about

മാത്രമുള്ളതാണ്, ഇത് പിന്നീട് വിശദമായി കാണും. പോയിന്ററുകൾ (pointer) ഉപയോഗിച്ച് ഒരു ചെറിയ കോഡ് സെഗ്മെന്റ് (code segment) നോക്കാം. ഇവിടെ

നമുക്ക് m, k എന്നീ രണ്ട് ഇന്റിജെർ വേരിയബിളുകളുണ്ട്

earlier. So, this tip says, if ip is not equal to null printf star ip or if ip printf star ip and

(integer variable), കൂടാതെ നമുക്ക് ptr എന്ന വേരിയബിൾ (variable) ഉണ്ട്, ഇത് യഥാർത്ഥത്തിൽ ടൈപ്പ് (type), ഇൻറിജർ പോയിന്റർ (integer pointer) ആണ്. നിങ്ങൾക്ക്

so, on.

ശ്രദ്ധിക്കാവുന്ന ഒരു കാര്യം, ഈ ഒരൊറ്റ

So, what this does is, it actually checks whether ip is null or not.

വരിയിൽ നമ്മൾ കുറച്ച് കാര്യങ്ങൾ ചെയ്തു, m, k എന്നീ രണ്ട് വേരിയബിളുകൾ (variable) ഡിക്ലയർ (declare)

If I know that it was initialized to null and at this point if ip is not equal to null,

ചെയ്യുകയും ഇനിഷ്യ ലായ്സ് (initialise) ചെയ്യുകയും ചെയ്തു, കൂടാതെ ഇന്റിജെർ പോയിന്റർ (integer pointer) തരത്തിന്റെ ഒരു പോയിന്റർ വേരിയബിളും (pointer variable)

then there was a valid assignment ip that happen here.

ഡിക്ലയർ (declare) ചെയ്തു. നിങ്ങൾക്ക് ഒരു വരിയിൽ

If there is no valid assignment, ip will still remain at null and you will not print the

ഡിക്ലറേഷനുകൾ (declaration) സംയോജിപ്പിക്കാൻ കഴിയും, ഒപ്പം ഇന്റിജർ വേരിയബിളുകളും (integer variable) പോയിന്ററുകളും (pointer) ഒരേ വരിയിൽ പ്രഖ്യാപിക്കാനുള്ള

value.

മാർഗമാണിത്. ഈ സാഹചര്യത്തിൽ ptr

So, this is a check that is done usually in practice. Again, we will see how this is useful when we do, what is called dynamic memory allocation. So, we have not done that yet,, but when we do ‘malloc’, we will use this template

k ലേക്ക് പോയിന്റു (point) ചെയ്യുന്നു. ptr =& k. കോഡിന്റെ (code) ഈ നാല് വരികൾ നോക്കാം. ആദ്യ വരിയിൽ m ന് മൂല്യത്തിന്റെ %d ഉണ്ടെന്നും അത് %p സൂക്ഷിക്കുന്നുവെന്നും പ്രിന്റ് എഫിന് (printf)

ഇൻപുട്ടുകളായി (input) രണ്ട് പാരാമീറ്ററുകൾ

later. So, another settle thing with C is that, it provides a pointer of type void.

(parameter) നൽകുന്നു. അതിനാൽ, നിങ്ങൾ ആദ്യം ശ്രദ്ധിക്കുന്നത്, ഈ % p പോയിന്ററുകൾക്കായുള്ള (pointer) ഒരു ഫോർമാറ്റ് സ്‌പെസിഫയറാണ്. (format specifier) നമുക്ക് ഇന്റിജറുകൾക്കുള്ള (integer) % d, ഫ്ലോട്ടിംഗ് പോയിന്റിനുള്ള (floating

. So, you declare it by saying void star v ptr and this void pointer is actually a generic

point) %f എന്നിവ പോലെ. പോയിന്ററുകൾക്കായി (pointer), നിങ്ങൾ %p , എന്നിവ ഉപയോഗിക്കാൻ ശുപാർശ ചെയ്യുന്നു. ഈ വരിയിൽ എന്താണ് സംഭവിക്കുന്നതെന്ന് നമുക്ക് നോക്കാം. ഒരു സ്‌പെസിഫയറായി

pointer.

(specifier) നിങ്ങൾക്ക് %d ഉണ്ട്, അത് m ലേക്ക്

What I mean by that is, it can be made to point at anything.

അറ്റാച്ചുചെയ്യും. ഇവിടെ m എന്നത് %d ഫോർമാറ്റായി

So, far we saw integers, star pointer.

(format) അച്ചടിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നു, അതിനർത്ഥം m ഒരു ഇന്റിജെറായി (integer) പ്രിന്റു (print) ചെയ്യുക, രണ്ടാമത്തെ ആർഗ്യുമെന്റ് (argument)

So, you could also have float star, ptr 1 and so, on.

m (void *)&k ആണ്. ടൈപ്പ്കാസ്റ്റിംഗ് (type casting) എന്ന് വിളിക്കുന്ന സാഹചര്യമാണിത്. & m പോയിന്റർ (pointer) തരത്തിലുള്ളതാണ്,

But, this void star v ptr is a generic pointer.

ഇത് ഒരു ഇന്റിജെർ പോയിന്റ് (integer pointer) തരമാണ്, അത് void * ഇലേക്ക് ടൈപ്പ് കാസ്റ് (type

You can make it point to an integer, you can make it point to a floating point, you can

cast) ചെയ്യുന്നു.. നിങ്ങൾക്ക് ഇന്റിറിലേക്കുള്ള (integer) ഒരു പോയിന്റർ (pointer) എടുത്ത് അതിനെ ഒരു സാധാരണ പോയിന്റർ (pointer) ആക്കാം. (void *)& m

make it to point a character or you can actually make it point to a pointer itself and so,

ന്റെ ഡാറ്റാ (data) തരം നോക്കുകയാണെങ്കിൽ, ഇത് ഇപ്പോൾ ഒരു വോയ്‌ഡ്‌ പോയിന്ററാണ് (void pointer),

on.

ഇത് ഇനി ഒരു ഇന്റിജെർ പോയിന്ററല്ല integer

So, this is another thing that comes very handy and this is just for you to notice now, we will see this in detail later.

pointer) , കൂടാതെ % p എന്ന ഫോർമാറ്റ് സ്‌പെസിഫയർ (format specifier) ഉപയോഗിച്ച് അച്ചടിക്കുന്നു. രണ്ടാമത്തെ വരിയിൽ k ന് % d ഉണ്ട്, k യുടെ

So, let us look at a small code segment using pointers. So, here we have two integer variables m and k and we have a variable ptr, which is actually

വിലാസം എന്തായാലും അത് സ്ഥാനത്ത് സൂക്ഷിക്കുന്നു. ptr എന്നത് ഒരു വേരിയബിളാണ് (variable), അതായത് ptr ന് ഇടം നൽകിയിട്ടുണ്ട് അല്ലെങ്കിൽ അതിന് കുറച്ച് മെമ്മറി (memory) നൽകുന്നു. ptr ന്

മൂല്യം %p ഉണ്ട്, അത് %p യിൽ സൂക്ഷിക്കുന്നു.

of the type, integer pointer.

ഈ സാഹചര്യത്തിൽ, ആദ്യത്തെ ആർ‌ഗ്യുമെൻറ്

So, one thing you can notice is that in this single line, we have done a few things, we

(argument) തന്നെ ഒരു പോയിന്ററാണ്, (pointer) രണ്ടാമത്തെ ആർ‌ഗ്യുമെൻറ് (argument) ptr ന്റെ വിലാസം എടുക്കുകയും അത് void * ഇലേക്ക് കാസ്റ്റുചെയ്യുകയും (cast) ചെയ്യുന്നു. അവസാന

have declared and initialized two variables m and k, we have also declared a pointer variable

വരി പറയുന്നത് ptr പോയിന്റ് (point) ചെയ്യുന്ന സംഖ്യയുടെ മൂല്യം %d ആണ്. ഞാൻ പറഞ്ഞതുപോലെ *ptr ptr നെ ഡീഫറൻസിംഗ് (dereferencing) ചെയ്യുന്നു. രണ്ട് വഴികളുണ്ട്,

of integer pointer type.

അതിൽ നിങ്ങൾക്ക് പോയിന്ററുമായി (pointer) ബന്ധപ്പെട്ട * ഉപയോഗിക്കാം. ഒന്ന് ഡിക്ലറേഷനുള്ളതാണ്

So, you can combine declarations in one line and this is the way to declare both integer variables and pointers to integers in the same line.

(declaration) , മറ്റൊന്ന് ഡീഫറൻസിംഗിന് (dereferencing) ഉപയോഗപ്രദമാണ്. ഇതിന് k ന്റെ r മൂല്യം ലഭിക്കുന്നു,

So, in this case ptr is made to point at k.

അത് k ന്റെ മൂല്യം പ്രിന്റു (print) ചെയ്യും.

So, ptr equals ampersand k is made to point.

ഈ സ്ലൈഡിൽ (slide) ശ്രദ്ധിക്കേണ്ട പ്രധാന കാര്യം, പോയിന്ററുകൾക്ക്

So, you are making ptr to point at k.

(pointer) %p സ്‌പെസിഫയർ (specifier) ഉണ്ട്, നമ്മൾ

So, let us look at these four lines of code.

ടൈപ്പ്കാസ്റ്റിംഗ് (type casting) ചെയ്തു. ഞങ്ങൾ

So, the first line says m has the value percentage d and is stored at percentage p and we give

ഇൻ‌റിജർ‌ പോയിന്റർ‌ (integer pointer)&m എടുത്തു, ഈ (void *) ഉപയോഗിച്ച് അതിനെ വോയ്‌ഡ്‌ പോയിന്ററിലേക്ക് (void pointer) പരിവർത്തനം ചെയ്‌തു. നിങ്ങൾ ഈ പ്രോഗ്രാം (program) എടുത്ത് മനസിലാക്കാൻ

two parameters as inputs to printf.

ശ്രമിക്കുക . പോയിന്ററുകളുടെ (pointer) ഒരു പ്രധാന ഉപയോഗം അത് അറേകൾ (array) കൈകാര്യം ചെയ്യുന്നതിന് ഉപയോഗിക്കുന്ന

So, the first thing you notice is, this percentage p is a format specifier for pointers.

ഒന്നാണ് എന്നതാണ്. സി ( C) യിൽ പോയിന്ററുകളും (pointer) അറേകളും തമ്മിൽ വളരെ ശക്തമായ ഒരു ബന്ധമുണ്ട്, കൂടാതെ അറേകൾ (array) ഉപയോഗിക്കാൻ ആഗ്രഹിക്കുമ്പോൾ പോയിന്ററുകൾ (pointer)

So, just like we have percentage d for integers, percentage f for floating point and so, on.

ഇല്ലാതെ നിങ്ങൾക്ക് സി (C)യിൽ കുറച്ച് കാര്യങ്ങൾ ചെയ്യാൻ കഴിയില്ല. ഫംഗ്ഷനുകൾ (function) നോക്കുമ്പോൾ ഇത് കൂടുതൽ വിശദമായി

For pointers, it is recommended that you use percentage p and.

കാണും. അതിനാൽ, പോയിന്ററുകളും (pointer) അറേകളും (array) തമ്മിൽ ശക്തമായ ബന്ധമുണ്ടെന്നും അറേ സബ്സ്ക്രിപ്റ്റുകൾ

So, let us see what happens in this line.

(subscript) ഉപയോഗിച്ച് നിങ്ങൾ ചെയ്യുന്നതെന്തും പോയിന്ററുകൾ (pointer) ഉപയോഗിച്ച് ചെയ്യാമെന്നും

You have percentage d as a specifier that will attach it to m.

പറയാം . ആ അർത്ഥത്തിൽ പോയിന്ററുകൾ (pointer), തുടർച്ചയായ ഒരു കൂട്ടം ലൊക്കേഷനുകളുമായോ

So, here you want m printed as percentage d format, which means print m as an integer

(location) അല്ലെങ്കിൽ തുടർച്ചയില്ലാത്തവയോ കൈകാര്യം ചെയ്യുന്നതിനുള്ള കൂടുതൽ ശക്തവും പൊതുവായതുമായ വഴിയാണ് .

and the second argument is void star ampersand of m.

നമുക്ക് ചെറിയ ഉദാഹരണം നോക്കാം, ഞാൻ നേരത്തെ പറഞ്ഞതുപോലെ നമുക്ക് int a[12] ഉണ്ട്. int a[12] a ക്കുവേണ്ടി

So, this is the case of what is called typecasting. So, ampersand of m is of pointer type and it is an integer point type, you typecast

ഒരു സ്ഥലം ഡിക്ലയർ (declare) ചെയ്യും , അത് നിങ്ങൾ കാണുന്ന ബോക്സുകളാണെന്ന് (box) പറയാം. A [0] ആദ്യ ലൊക്കേഷനാണെന്നും (location) a [1] രണ്ടാമത്തെ സ്ഥാനമാണെന്നും a [ 11] അവസാന സ്ഥാനമാണെന്നും

നമുക്കറിയാം. അതിനാൽ, ഇൻഡക്സുകൾ (index) 0 മുതൽ

that into what is called void star. So, you can take a pointer which is of integer type and make it a generic pointer. So, if you look at the data type of void star ampersand m, it is actually a void pointer

11 വരെ പോകുന്നു, 12 എന്നത് a യുടെ സാധുവായ ഇൻഡക്സ് (index) അല്ല . എനിക്ക് int star ptr (* ptr) ഉണ്ടെങ്കിൽ, ഇത് എനിക്ക് ptr എന്ന മെമ്മറി

now, it is not an integer pointer anymore and you are printing that using a format specifier

(memory) സ്ഥാനം നൽകും. ഇവയിൽ ഏതെങ്കിലും ഒന്ന് ഞാൻ ചെയ്യുകയാണെങ്കിൽ, ptr =&a [0] അല്ലെങ്കിൽ ptr[a] എന്ന് പറഞ്ഞാൽ, ptr ഇവിടെ പോയിന്റ്

for you called percentage p.

(point) ചെയ്യാൻ തുടങ്ങുന്നു. ഇവിടെ ശരിക്കും എന്താണ്

So, in the second line k has the value percentage d and is stored at location, whatever is the

സംഭവിക്കുന്നതെന്ന് നമുക്ക് നോക്കാം. ആദ്യം ഈ സ്റ്റേറ്റ്മെന്റ് (statement) നോക്കാം. ഞാൻ ഈ സ്റ്റേറ്റ്മെന്റ് (statement) നോക്കിയാൽ, ptr=&a[0]. ഇത് എന്താണ് ചെയ്യുന്നതെന്ന് നമുക്ക് നോക്കാം.

a[0] ഒരു മൂല്യം ആണ്, അത് ഒരു പോയിന്റർ

address of k. So, I already showed something very similar.

(pointer) അല്ല. ഇത് അറേയിൽ (array) കണ്ടു. പക്ഷേ,

So, ptr itself is a variable which means ptr is given space or it is given some memory.

നിങ്ങൾ & മുന്നിൽ ഇടുന്ന നിമിഷം, അതിനർത്ഥം 0-ൽ സംഭരിച്ചിരിക്കുന്ന ഒരു മൂല്യം ലഭിക്കരുത് എന്നാണ്, പകരം 0-ാം ഘടകത്തിലേക്ക് പോയിന്റർ (pointer) നൽകുക എന്നാണ്. ഇടത് വശത്ത് ഒരു

So, it is given a memory location.

പോയിന്റർ (pointer) ആവശ്യപ്പെടുന്നു, വലതുവശത്ത് യഥാർത്ഥത്തിൽ

So, ptr has the value percentage p and stored at percentage p.

ഒരു പോയിന്റർ (pointer) നൽകുന്നു. അതിനാൽ, ഇത് സാധുവാണ്. ഇത് ശരിക്കും ചെയ്യുന്നത്,

So, in this case this one, the first argument itself is a pointer and the second argument

ptr a യുടെ 0 മത്തെ ഘടകത്തിലേക്ക് പോയിന്റു (point) ചെയ്യാൻ തുടങ്ങുന്നു. കുറുക്കുവഴിയിലൂടെയും നിങ്ങൾക്ക് ഇത് നേടാൻ കഴിയും, അത് ptr= a. ഇത് നിങ്ങൾ കാണുന്ന ഒരു

is taking the address of ptr and casting that to void star.

കാര്യമാണ്, ഒരു നല്ല പ്രോഗ്രാമർമാർ (programmer) ചെയ്യുന്നു. പരിചയസമ്പന്നരായ പ്രോഗ്രാമർമാർ (programmer)

And finally, the last line says the value of the integer pointed to by ptr is percentage

ഈ ഫോർമാറ്റ് (format) ഉപയോഗിക്കുന്നില്ല, പകരം അവർ ptr =a ചെയ്യുന്നു. ഇത് ചെയ്യുന്നത്, ptr ഇപ്പോൾ a യുടെ 0 മത്തെ

ഘടകത്തിന്റെ വിലാസം ഉൾക്കൊള്ളാൻ പോകുന്നു.

So, star ptr as I said is dereferencing ptr. So, see here, you are not declaring ptr.

ചില അർത്ഥത്തിൽ a എന്ന അറേയുടെ (array)

So, that has already happened in this line, here you are doing dereferencing of ptr.

പേര് യഥാർത്ഥത്തിൽ 0 മത്തെ ഘടകത്തിന്റെ വിലാസത്തിന്റെ പര്യായമാണ്. അതിനാൽ, a എന്ന് പറയുമ്പോൾ,

So, this is what I was pointing to earlier. So, there are two ways, in which you can use the star associated with the pointer. One is for declaration, the other one we are seeing here, which useful for dereferencing.

a എന്നത് 12 വലുപ്പമുള്ള ഒരു ഇന്റിജെർ അറേ integer array) ആണ്. എന്നാൽ, വേരിയബിൾ (variable) a യഥാർത്ഥത്തിൽ

So, it is getting the r value of k and it will print the value of k.

ഈ അറേയുടെ (array) 0 മത്തെ ഘടകത്തിന്റെ വിലാസത്തിന്റെ

So, the key thing to notice in this slide is, there is percentage p specifier for pointers and we did what is called typecasting.

പര്യായമാണ്. int *ptr =a. ഈ കോഡിൽ (code), നിങ്ങൾ ptr എന്ന് വിളിക്കുന്ന

We took integer pointer ampersand m and we converted that to void pointer using this

ഒരു ഇന്റിജെർ പോയിന്റർ (integer pointer) ഡിക്ലയർ (declare) ചെയ്യുകയാണ്. ഒരു ഇന്റിജെർ പോയിന്റർ

bracket void star.

(integer pointer) ഡിക്ലയർ (declare) ചെയ്യുകയാണെന്നും

So, I suggest that you actually take this piece of program and tried it out to understand,

വേരിയബിൾ (variable) നാമം ptr എന്നും a ലേക്ക് ഇനിഷ്യലായസ് (initialise) ചെയ്യുകയും ചെയ്യുന്നു.

what is happening there. So, one key use of pointers is that it is something that is used for manipulating arrays.

‘a’ അറേ (array) ആണെങ്കിൽ, ptr 0-ാം സ്ഥാനത്തേക്ക് പോയിന്റുചെയ്യാൻ (point) ആരംഭിക്കുന്നു.

So, in C there is a very, very strong relationship between pointers and arrays and without pointers

അതിനാൽ, വിലാസത്തിന്റെ പര്യായമായി a ഉപയോഗിക്കാം

you cannot do a few things in C, when you actually want to use arrays.

നിങ്ങൾക്ക് ptr ഉപയോഗിച്ച് ചെയ്യാൻ കഴിയുന്ന

So, we will see this again in more detail, when we look at functions. So, you take it for now that there is a strong relationship between pointers and arrays and

നല്ല കാര്യം, നിങ്ങൾക്ക്, ptr =ptr+1 എന്ന് കൊടുക്കാം എന്നതാണ്. ഇതിന്റെ അർത്ഥമെന്താണെന്ന് നമുക്ക് നോക്കാം, വലതുവശത്ത്, ഒരു

anything that you do using array subscripts can actually be done using pointers.

പോയിന്റർ വേരിയബിൾ (pointer variable) ഉണ്ട്, അതിലേക്ക്

So, pointers in that sense, is more powerful and more generic way of dealing with either

1 ചേർക്കുന്നു. അതിനർത്ഥം, a [0] യിലേക്ക് പോയിന്റ് (point) ചെയ്യുന്നതിനുപകരം, അടുത്ത ഘടകത്തിലേക്ക്

contiguous set of locations or something that is not contiguous. So, let us see the small example, we have int a of 12 as I said earlier, int a of 12

പോയിന്റ് (point) ചെയ്യുന്നു. ഈ സമയത്ത് ptr [0] എന്നതിലേക്കാണ് പോയിന്റ് (point) ചെയ്യുന്നത്. നിങ്ങൾക്ക് അത് ഇവിടെ

will declares space for a and let us say that is the top set of boxes that you are seeing.

കാണാം. പക്ഷേ, നിങ്ങൾ ptr=ptr+1 ചെയ്യുമ്പോൾ അടുത്ത ഘടകത്തിലേക്ക് പോയിന്റു (point)ചെയ്യാൻ

And we know that a of 0 is the very first location, a of 1 is the second location and

ആരംഭിക്കുന്നു. വീണ്ടും ptr=ptr+1 ചെയ്താൽ, അത് 2 ആം സ്ഥാനത്തേക്ക്

so, on and a of 11 would be the last location.

പോയിന്റുചെയ്യാൻ തുടങ്ങും, ഇത് 0 മുതൽ

So, indexes go from 0 to 11, 12 is not a valid index for a.

ആരംഭിക്കുന്നു. 0, 1, 2 എന്നിങ്ങനെ പോകുന്നു. പൂർണ്ണസംഖ്യകളിലും മറ്റും നിങ്ങൾ ചെയ്യുന്നതുപോലെ

So, if I have int star ptr (*ptr), this will give me a memory location called ptr.

ഗണിതശാസ്ത്രം പോലെ ഉപയോഗിക്കാം. പക്ഷേ, ചില നിയമങ്ങളുണ്ട്; ഇത് കുറച്ചുകൂടി വിശദമായി കുറച്ച് കാണും. നിങ്ങൾ ചിന്തിക്കാൻ

And if I do either of these two, if I say ptr equals ampersand of a of 0 or ptr of a,

ആഗ്രഹിക്കുന്ന ഒരു കാര്യം, *ptr=*ptr+1 എന്താണ് ചെയ്യുന്നത്. വ്യക്തമായി ptr=ptr+1, * ptr =*ptr+1 ഇവ തമ്മിൽ വ്യത്യാസമുണ്ട്. കുറച്ച് സമയമെടുത്ത്

then ptr starts pointing here.

അതിനെക്കുറിച്ച് ചിന്തിക്കുക. നമുക്ക് അറേകളിലേക്ക് മടങ്ങാം, അറേകൾ പോയിന്ററുകളേക്കാൾ

So, let us see, what really happens here.

വഴക്കമുള്ളവയാണ്. അതിനാൽ, അറേകളെ (array)

So, let us look at this statement first.

കോൺസ്റ്റന്റ് പോയിന്ററുകൾ (constant pointer) എന്ന് വിളിക്കുന്നു.

So, if I look at this statement, ptr is ampersand of, a of 0. So, let us see what this does. So, a of 0 is a value, it is not a pointer, a of 0 is actually a value,. So, we have seen this in array so, far.

ഇടതുവശത്തുള്ള കോഡിന്റെ (code) ഒരു ഭാഗം നോക്കാം, നമുക്ക് int a[10] ഉം നമുക്ക് int *pa യും ഉണ്ട്. pa എന്നത് ഒരു ഇന്റിജെർ പോയിന്ററാണ്‌ (integer pointer) , pa = a ന് തുല്യമാണെന്ന്

But, the moment you put ampersand in front of it, it means do not get a value that is

stored in a of 0, instead give me the pointer to the 0th element. So, the left side is asking for a pointer and the right side actually gives a pointer. So, this is valid.

പറഞ്ഞപ്പോൾ, ഇപ്പോൾ pa a യുടെ 0 മത്തെ സ്ഥാനത്തേക്ക് പോയിന്റു (point) ചെയ്യാൻ

So, what is this really doing is, ptr begins to point at the 0th element of a. You can also achieve the same thing by a slighter shortcut, which says ptr equals a. So, this is also something that you will see, a good programmers doing.

ആരംഭിക്കുന്നു. നിങ്ങൾ pa++ ചെയ്യുകയാണെങ്കിൽ, pa വർദ്ധിപ്പിക്കുകയാണ്, അത് എന്താണ് ചെയ്യുന്നത്, pa പോയിന്റിനെ (pointer) 1 എന്നതിലേക്ക് മാറ്റുന്നു. ഇത് ചെയ്യുന്നത് ശരിയാണ്, കാരണം പോയിന്ററുകൾ

So, experienced programmers do not use this format, instead they use ptr equals a. So, what this is doing is, ptr is now going to contain the address of the 0th element of a.

(pointer) വേരിയബിളുകളാണ് (variable), ഇവിടെ നിങ്ങൾ pa ലേക്ക് ഒരു അസൈൻമെന്റ് (assignment) നടത്തി, നിങ്ങൾ

So, in some sense the name of the array a is actually only a synonym to the address

of the 0th element. So, when we say a, a is an integer array of size 12. But, the variable a is actually just a synonym for the address of the 0th element of this array.

ഇവിടെ അസൈൻമെന്റ് (assignment) pa ലേക്ക് മാറ്റുന്നു,

Let us see, what all these means. So, if I do int star ptr equals a.

So, in this piece of code, you are declaring an integer pointer called ptr. So, this says we are declaring an integer pointer and the variable name is ptr and right when we are declaring, we are also initializing it to a. So, if ‘a’ is, this array that we have here, then ptr starts pointing at the 0th

ഇത് pa ന് തികച്ചും അനുയോജ്യമാണ്, കാരണം pa ഒരു വേരിയബിൾ (variable) ആണ്. ചുവന്ന ബോക്സിൽ വലതുവശത്ത്, int a[10] ഉണ്ട്, int *pa ഉണ്ട്,

location. So, this is something that comes from the using a as a synonym for the address. But, the nice thing you can do with ptr is that you can do something like this, ptr is

ptr plus 1. So, let us see what this means, on the right side, we actually have a pointer variable

‘a’ എന്നത് ‘pa’ എന്നതിന് തുല്യമാണ്. ആദ്യത്തെ കാര്യം, a= pa എന്നത് അനുവദനീയമല്ല എന്നതാണ്,

and we are adding 1 to it. So, what; that means, is, instead of making ptr point at a of 0, now you actually pointed

a=pa ചെയ്യുമ്പോൾ, 10 സ്ഥലങ്ങളിൽ പോയിന്റു (point ) ചെയ്യേണ്ടതാണ്, കൂടാതെ ഇപ്പോൾ pa സൂചിപ്പിക്കുന്നത്

to the next element after the current one.

പോലെ മറ്റേതെങ്കിലും സ്ഥലത്ത് പോയിന്റ് (point) ചെയ്യാൻ ആവശ്യപ്പെടുന്നു. ഇത് അനുവദനീയമല്ല

So, at this point ptr was pointing at a of 0.

കൂടാതെ a++ അനുവദനീയവുമല്ല. അതിനാൽ, ‘എ’ എന്നത്

So, you can see that here.

0-ാമത്തെ സ്ഥാനത്തിന്റെ പര്യായമാണെങ്കിലും,

But, the moment you do ptr is ptr plus 1; it is starts pointing to the next element.

അറേയ്‌ക്ക് (array ) ഉപയോഗിക്കുന്ന വേരിയബിൾ നാമം എടുക്കുന്നതിന് സാധുതയില്ല, ഒപ്പം അതിൽ ഏതെങ്കിലും

So, clearly you can see that if you do ptr is, if you do another ptr equals ptr plus 1, it will start pointing to the 2th location and so, on. So, it is starts with 0th.

തരത്തിലുള്ള ഗണിതശാസ്ത്രവും ചെയ്യാനും കഴിയില്ല. നിങ്ങൾക്ക് a ++ ചെയ്യാൻ കഴിയില്ല, a = pa അല്ലെങ്കിൽ

So, like as I said, I abuse this, abuse English language I say 0th, 1th and 2th and so, on. So, right now it is pointing at 0th location and if you do ptr is ptr plus 1, it will starts pointing at the 1th location. And if you do one more ptr equals ptr plus 1 and it is starts pointing at 2th location

അത്തരത്തിലുള്ള ഒന്നും ചെയ്യാൻ കഴിയില്ല.

and so, on. So, we can use like arithmetic, like you would do on integers and so, on. But, there are certain rules; we will see this in a little more detail in a little wide.

So, one thing I would want you to think about is, what does star ptr equals star ptr plus 1 do? So, clearly there is a difference between saying ptr equals ptr plus 1 versus star ptr equals star ptr plus 1.

ചുരുക്കത്തിൽ ‘a’ ഒരു എക്സ്പ്രഷന്റെയും

So, take some time and think about it. So, it will be useful to think about, what this statement ptr equals ptr plus 1 does versus star ptr equals star ptr plus 1 does? Take a while to think about it.

So, let us go back to arrays, so, in some sense arrays I said are less flexible than pointers. So, arrays are what are actually called constant pointers. So, let us look at piece of code on the left side, we have int a of 10 and we have int

(expression) ഇടതുവശത്ത് ദൃശ്യമാകില്ല. A ++

star pa. So, pa is an integer pointer and when we said pa equals a, now pa starts pointing at the 0th location of a. And if you do pa plus plus, we are incrementing pa, what it does is, it makes pa point at

യഥാർത്ഥത്തിൽ 'a' =a +1 ന് തുല്യമാണ്., അതേസമയം,

a of 1 instead. So, this is actually ok to do because, pointers are variables and here you did one assignment to pa and you change the assignment to pa here, which is perfectly fine for pa, because pa is a variable.

Let us do something which is slightly different here. On the right side in the red box, we have int a of 10, we have int star pa and we say ‘a’ equals ‘pa’. So, the first thing is that a equals pa is not permitted at all, so, this is not permitted.

The reason is that when we do a equals pa, a is supposed to point at some 10 locations and we are now asking a to point at some other location, as indicated by pa. So, this is not allowed nor is a plus plus allowed. So, even though ‘a’ is the synonym for the 0th location, it is not valid to take

pa ഒരു വേരിയബിൾ (variable) ആയതിനാൽ, സ്വതന്ത്രമായി ഇടത് വശത്തു ദൃശ്യമാകും. വേരിയബിൾ (variable) ‘a ’ യഥാർത്ഥത്തിൽ ഒരു അറേ (array) ആണ്, അതിനെ കോൺസ്റ്റന്റ് പോയിന്റർ

the variable name, that is used for the array and do any kind of arithmetic on it. You cannot do a plus plus, you cannot do a equals pa or anything of that sort.

(constant pointer) എന്ന് വിളിക്കുന്നു. കോൺസ്റ്റന്റ് പോയിന്റർ (constant pointer) എന്നതുകൊണ്ട് ഞാൻ ഉദ്ദേശിക്കുന്നത് a യഥാർത്ഥത്തിൽ 10 സ്ഥാനങ്ങളുടെ ഒരു

So, to summarize ‘a’ cannot appear in the left side of any expression. So, a plus plus is actually just ‘a’ equals a plus 1.

കൂട്ടമാണ്. അതിനാൽ, 10 സ്ഥാനങ്ങളുണ്ട്, സാങ്കേതികമായി 'a' എന്നത് a [0 ] യിലേക്ക് പോയിന്റ് (point) ചെയ്യുന്നു , ഇതിന് 0-ൽ അല്ലാതെ മറ്റൊന്നും പോയിന്റ് ചെയ്യാൻ കഴിയില്ല.

So, ‘a’ cannot appear in the left side of any manipulation at all of any expressions at all, whereas, pa being a variable, can appear freely on the left side. So, the variable ‘a’ is actually an array and it is called a constant pointer. So, what I mean by the constant pointer is that a of 10 is actually a set of 10 locations.

അതാണ് കോൺസ്റ്റന്റ് പോയിന്റർ എന്നതുകൊണ്ട് ഞാൻ അർത്ഥമാക്കുന്നത്, int a [10 ] ഉപയോഗിച്ചാൽ 0 എന്നതിലേക്ക് പോയിന്റ് (point) ചെയ്യാൻ കഴിയും,

So, we have 10 locations and ‘a’ is actually pointing to a of 0, technically and it cannot point at anything other than a of 0. That is what I mean by constant pointer, a can point at a of 0 and nothing else, the moment using int a of 10.