Pointers Programming, Data Structures and Algorithms English Malayalam

PointersYouTube↗ IA↗(long shot)
People & Blogs 4K views 12 likes 0 dislikes 30 Jan 2018

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

In this module, what we are going to look at is very interesting aspect that C and several other programming languages give you, which

ഈ മൊഡ്യൂളിൽ (module), നമ്മൾ കാണാൻ പോകുന്നത് സി (C) യും മറ്റ് നിരവധി പ്രോഗ്രാമിംഗ് (programming) ഭാഷകളും നൽകുന്ന വളരെ രസകരമായ ഒരു വശമാണ്, ഇത് വേരിയബിളുകളിൽ (variable) സംഭരിച്ചിരിക്കുന്ന

is not just accessing values that are stored in variables, but also getting access to the

മൂല്യങ്ങൾ ആക്സസ് (access) ചെയ്യുക മാത്രമല്ല, മെമ്മറി ലൊക്കേഷനുകളിലേക്കോ (memory location) അഡ്രസ്സുകളിലേക്കോ

memory locations or the addresses.

(address) പ്രവേശനം നേടുന്നു.

So, what is a pointer? So, to do that let us remember what happens, when we declare a variable called k.

എന്താണ് ഒരു പോയിന്റർ (pointer)? അത് ചെയ്യുന്നതിന് k എന്ന വേരിയബിൾ (variable)

So, if I do int k, k is the name of a memory location that can hold a single value at a

പ്രഖ്യാപിക്കുമ്പോൾ എന്താണ് സംഭവിക്കുന്നതെന്ന് ഓർമ്മിക്കാം. ഞാൻ int k ചെയ്യുകയാണെങ്കിൽ, ഒരു സമയം ഒരു മൂല്യം നിലനിർത്താൻ കഴിയുന്ന ഒരു മെമ്മറി ലൊക്കേഷന്റെ

time. So, for instance if I have int k, k could be a given array location 100 and at some

(memory location) പേരാണ് k. ഉദാഹരണത്തിന്, എനിക്ക് int k ഉണ്ടെങ്കിൽ, k ഒരു നിശ്ചിത അറേ ലൊക്കേഷൻ (array location)

point of time, you could have k equals 38 and the value 38 will get into this location called k.

100 ആകാം, ചില സമയങ്ങളിൽ, നിങ്ങൾക്ക് k 38 ന് തുല്യമാകാം, കൂടാതെ 38 ന്റെ മൂല്യം k എന്ന

So, from the programs perspective, we are going to use k which is the name of the variable, internally it is stored in location 100 and the value that is stored is 38.

ഈ സ്ഥാനത്തേക്ക് ലഭിക്കും. അതിനാൽ, പ്രോഗ്രാമുകളുടെ (program) വീക്ഷണകോണിൽ നിന്ന്, നമ്മൾ വേരിയബിളിന്റെ (variable) പേരായ k ഉപയോഗിക്കാൻ പോകുന്നു, ആന്തരികമായി ഇത് സ്ഥാനം 100 ൽ സൂക്ഷിക്കുന്നു,

So, that is the concept of a variable. Now, what is a pointer?

സംഭരിച്ചിരിക്കുന്ന മൂല്യം 38 ആണ്. അതാണ് ഒരു വേരിയബിളിന്റെ (variable) ആശയം. ഇപ്പോൾ,

A pointer is essentially a variable and in this example, we have this thing called int

എന്താണ് ഒരു പോയിന്റർ (pointer)? ഒരു പോയിന്റർ അടിസ്ഥാനപരമായി ഒരു വേരിയബിളാണ് (variable), ഈ ഉദാഹരണത്തിൽ, നമുക്ക് int *p എന്ന്

star p.

വിളിക്കുന്നു.

So, the key thing to note here is this thing called star, it is not int p, it is int star

ഇവിടെ ശ്രദ്ധിക്കേണ്ട പ്രധാന കാര്യം * എന്ന് വിളിക്കുന്ന ഈ കാര്യമാണ്, അത് int p അല്ല, അത് int

p (int *p). So, remember star is not a valid character in a variable name for C. So, this star is

* p ആണ്. സി (C) യിൽ വേരിയബിൾ (variable) നാമത്തിൽ * സാധുവായ പ്രതീകമല്ലെന്ന് ഓർക്കുക. അതിനാൽ, ഈ * പ്രത്യേകമായി കരുതിവച്ചിരിക്കുന്നു.

reserved for something specific.

ഈ സാഹചര്യത്തിൽ, p ഒരു ഇന്റിജെറിലേക്കുള്ള

In this case, p is supposed to be a pointer to an integer.

(integer) പോയിന്ററായിരിക്കണം (pointer). ഇത് എന്താണ് ചെയ്യുന്നതെന്ന് നമുക്ക് നോക്കാം.

So, let us see what this does. If I declare something called int star p, this p can contain memory locations instead

ഞാൻ int *p എന്ന് വിളിക്കുന്ന എന്തെങ്കിലും പ്രഖ്യാപിക്കുകയാണെങ്കിൽ, ഈ p ന് യഥാർത്ഥ മൂല്യത്തിന് പകരം മെമ്മറി (memory)

of the actual value.

സ്ഥാനങ്ങൾ ഉൾക്കൊള്ളാൻ കഴിയും.

So, let us see what that means, so p is a variable as we had before which means, your

അതിന്റെ അർത്ഥമെന്താണെന്ന് നമുക്ക് നോക്കാം, p എന്നത് നമുക്ക് മുമ്പ് ഉണ്ടായിരുന്നതുപോലെ ഒരു വേരിയബിളാണ് (variable), അതിനർത്ഥം നിങ്ങളുടെ

compiler is going to allocate some location for it.

കംപൈലർ (compiler) അതിനായി കുറച്ച് സ്ഥാനം അനുവദിക്കാൻ

So, let us say p as a variable is allocated location 200 and when you say int star p,

പോകുന്നു. ഒരു വേരിയബിളിന് (variable) സ്ഥാനം 200 അനുവദിച്ചതിനാൽ നമുക്ക് p എന്ന് പറയാം, നിങ്ങൾ int *p എന്ന്

it means it is a pointer.

പറയുമ്പോൾ, ഇത് ഒരു പോയിന്റർ (pointer) എന്നാണ്

If I put int star p equals to 100, the value 100 gets into this location 200 and if I do

അർത്ഥമാക്കുന്നത്. int * p 100 ന് തുല്യമാണെങ്കിൽ, 100 ന്റെ മൂല്യം ഈ സ്ഥാനത്ത് 200 ൽ പ്രവേശിക്കുന്നു, ഞാൻ *p ചെയ്താൽ, അതിന്റെ

star p, star p is an operation that you are doing. The meaning of that is, you take location 100 see, what that is pointing to.

അർത്ഥം, സ്ഥാനം 100 കാണുക. അതിനാൽ, ഞാൻ 100 എടുക്കുന്നു, അത് ഒരു മൂല്യമായി വായിക്കുന്നതിനുപകരം ഒരു വിലാസമായും ആ വിലാസത്തിൽ നിലവിലുള്ള മൂല്യം എന്താണ് എന്ന്

So, I take the value 100, instead of reading it as a value I read that as an address and in that address, what is the value that is present?

നോക്കുന്നു. നിലവിലുള്ള മൂല്യം 38 ആണ്, p ഒരു ഇന്റിജെറാണ് (integer) അതിന്റെ അർത്ഥമെന്തെന്നാൽ, നിങ്ങൾ പരാമർശിക്കാൻ പോകുന്ന സംഭരിച്ചിരിക്കുന്ന മൂല്യം യഥാർത്ഥത്തിൽ

So, the value that is present is 38, so p is an integer pointer.

ഒരു ഇന്റിജെറാണ് (integer), p അതിലേക്ക് വിരൽ ചൂണ്ടുന്നു, p 38 ന്റെ മൂല്യം ഉൾക്കൊള്ളുന്നില്ല,

What that means is, the value that is stored that you are going to reference to is actually

എന്നാൽ p ൽ 38 സംഭരിച്ചിരിക്കുന്ന വിലാസം അടങ്ങിയിരിക്കുന്നു.

an integer, p is just pointing to it, p does not contain the value 38, but p contains the

ഇത് നോക്കാനുള്ള ഒരു മാർഗം ഇനിപ്പറയുന്നതാണ്. നമുക്ക് ഡിപ്പാർട്ട്മെന്റിൽ (department) ഒരു എച്ച്ഒഡി (HOD) ഉണ്ട്, ഡിപ്പാർട്ട്മെന്റ് ഹെഡ് (department head).

address in which 38 is stored.

അതിനാൽ, ഇത് യഥാർത്ഥത്തിൽ ഒരു വ്യക്തിയാണ്,

So, one way to look at this is as follows.

അതിനാൽ HOD- കൾ ആകാൻ സാധ്യതയുള്ള നിരവധി

So, let us say we have, in our department we have a HOD and so the Head of the Department.

ആളുകളുണ്ടെന്ന് കരുതുക. എന്നാൽ, ഏത് സമയത്തും, വകുപ്പിന്റെ തലവനായ ഒരൊറ്റ വ്യക്തി മാത്രമേയുള്ളൂ. ഒരു വിദ്യാർത്ഥിയെന്ന നിലയിൽ നിങ്ങൾ നടക്കുകയും

എച്ച്ഒഡി (HOD) ആരാണെന്ന് കണ്ടെത്തുകയും ചെയ്യണമെന്ന്

So, it is actually a person, so let us assume that there are people and there are several

പറയട്ടെ. അതിനാൽ, നിങ്ങൾക്ക് പോയി ഈ ഫാക്കൽറ്റി (faculty) അംഗങ്ങളിൽ ഓരോരുത്തരോടും എച്ച്ഒഡി (HOD) ആരാണെന്ന്

people who could be HOD’s.

ചോദിക്കാം. പക്ഷേ, എച്ച്ഒഡി (HOD) എന്ന ആശയം എല്ലായ്പ്പോഴും

But, at any point of time, there is only a single person who is the head of the department.

ഒരു വ്യക്തി മാത്രമാണ്. നിലവിലെ എച്ച്ഒഡി (HOD) പ്രൊഫസർ ഇസഡ് (professor

Let us say, you as a student walk in and you want to find out, who the HOD is.

Z) ആണെന്ന് പറയുന്ന ഈ ചെറിയ മാർക്കർ എനിക്കുണ്ടെന്ന് നമുക്ക് പറയാം.

So, of course you could go and ask each one of these faculty members who the HOD is.

അതിനാൽ, എക്സ്, വൈ, ഇസെഡ് (X, Y, Z) എന്നീ മൂന്ന് പ്രൊഫസർമാരുണ്ടെന്ന് (professor) കരുതുക, നിങ്ങൾ

But, the notion of HOD is always just one person.

വന്ന് നിലവിലെ എച്ച്ഒഡി (HOD) ആരാണെന്ന് ചോദിക്കുക,

Let us say I have, this small marker which says, the current HOD is person professor

ഞാൻ പറയുന്നു നിലവിലെ HOD Z ആണെന്ന്. നിലവിലെ HOD ആരാണെന്ന് നിങ്ങൾ അറിയേണ്ടതില്ല. നിലവിലെ എച്ച്ഒഡി (HOD) ആരാണെന്ന് നിങ്ങൾ

Z. So, let us assume that there are three professors, X, Y and Z and you come in and ask who is

ചോദിക്കുകയും പ്രൊഫസർ ഇസഡിനെ (professor Z) ചൂണ്ടിക്കാണിക്കുകയും ചെയ്യും. ഭാവിയിൽ ചില സമയങ്ങളിൽ പ്രൊഫസർ ഇസഡ് (professor

the current HOD and I say that the current HOD is Z.

Z) എച്ച്ഒഡി (HOD) ആയി സ്ഥാനമൊഴിയുകയും

So, that way from outside, you do not have to know who the current HOD is.

പ്രൊഫസർ എക്സ് (professor X) ഹെഡ്ഷിപ്പ് (headship) എടുക്കുന്നുവെന്ന് പറയട്ടെ, തുടർന്ന്

You ask who the current HOD is and you get pointed to professor Z.

പോയിന്റർ (pointer) എക്സിലേക്ക് (X) പോയിന്റുചെയ്യുന്നു. മറ്റൊരാൾ നടന്ന് അതേ ചോദ്യം ചോദിക്കുക,

At some point of time in the future, professor Z steps down as HOD and let us say professor

നിലവിലെ HOD ആരാണ്? ഈ പോയിന്റർ (pointer), ഇപ്പോൾ X- ലേക്ക് സൂചിപ്പിക്കാൻ

X takes of the headship, then the pointer points to X.

കഴിയും, Z- ലേക്ക് അല്ല. അതിനാൽ, ആ വഴി നിങ്ങൾക്ക് യഥാർത്ഥത്തിൽ ലഭിക്കുന്നത് യഥാർത്ഥ മൂല്യമല്ല, അത് X, Y അല്ലെങ്കിൽ Z ആണ്,

So, again let us say somebody else walks in and ask the same question, who is the current

എന്നാൽ നിങ്ങൾക്ക് യഥാർത്ഥ മൂല്യത്തിലേക്ക് പോയിന്റർ (pointer) ലഭിക്കുന്നു. ഇത് വളരെ ഉപയോഗപ്രദമാണ്, ഇത് ഡിപ്പാർട്ട്മെന്റിൽ

HOD?

(department) ഉള്ള ഒന്നാണ്.

This pointer, can now point to X and not Z.

നമ്മുടെ ഡിപ്പാർട്ട്മെന്റിൽ (department) നമുക്ക് [email protected] എന്ന ഇമെയിൽ (e-mail) വിലാസം ഉണ്ട്.

So, that way what you are actually getting is not the actual value, which is X, Y or

ഈ [email protected] ഒരു ശാശ്വത ഇമെയിൽ (email) വിലാസമാണ്,

Z, but you are getting the pointer to the actual value.

എന്നാൽ ഇത് വ്യത്യസ്ത സമയങ്ങളിൽ വ്യത്യസ്ത ആളുകളെ ചൂണ്ടിക്കാണിക്കുന്നു.

So, this is very useful for instance, this is something that we have in our department.

ഉദാഹരണത്തിന്, 2013 ലെ ഞങ്ങളുടെ നിലവിലെ എച്ച്ഒഡി, (HOD) അദ്ദേഹത്തിന്റെ ഇമെയിൽ (email) വിലാസം

So, in our department we have an email address called [email protected].

ഇപ്പോൾ ചൂണ്ടിക്കാണിക്കപ്പെടുന്നു. സ്ഥാനം ഉപേക്ഷിക്കാൻ അദ്ദേഹത്തിന്റെ ഊഴം വരുമ്പോൾ, 2015 ൽ മറ്റൊരാൾ എച്ച്ഒഡിയായി (HOD) മാറുന്നുവെന്ന് നമുക്ക് പറയാം, പ്രൊഫസർ

So, this [email protected] is a permanent email address, but this in turn points to

വൈ (Professor Y) എച്ച്ഒഡിയായി (HOD) മാറുന്നു. തുടർന്ന്, പ്രൊഫസർ എക്സിലേക്ക് (Professor X) പോയിന്റുചെയ്യുന്ന (point) പോയിന്റർ (pointer) എനിക്ക് നീക്കംചെയ്യാൻ കഴിയും, പകരം പ്രൊഫസർ

different people at different times.

വൈയിലേക്ക് (Professor Y) ഈ പോയിന്റർ (pointer)

So, for instance our current HOD in year 2013, his email address is pointed to now.

പോയിന്റ് (point) ചെയ്യാനാകും, ഈ രീതിയിൽ, നിങ്ങൾ എല്ലായ്പ്പോഴും സി‌എസ്‌ഇയിലേക്ക് (CSE) ഇമെയിൽ അയയ്‌ക്കുകയും ആന്തരിക പോയിന്റർ

When his turn comes to give up the position, let us say in 2015 somebody else becomes the

(pointer) നിലവിലെ HOD ആരാണ് എന്നതനുസരിച്ച് പ്രൊഫസർ എക്സ് (Professor X) അല്ലെങ്കിൽ വൈ (Y)

HOD, let us say professor Y becomes the HOD.

അല്ലെങ്കിൽ Z ലേക്ക് കൈമാറുകയും ചെയ്യും,.

Then, I can remove the pointer pointing to professor X and I can instead make that pointer

ഇത് വളരെ ഉപയോഗപ്രദമായ ഒരു ആശയമാണ്, ഇതിന്റെ ഉദാഹരണങ്ങൾ പിന്നീട് കാണും. പക്ഷേ, ഇപ്പോൾ ഓർക്കുക, p എന്നത് മറ്റേതൊരു

point to professor Y and this way, you always will email head at CSE and the internal pointer

വേരിയബിളിനെയും (variable) പോലെയാണ്. ഇതിന് ഒരു മെമ്മറി(memory) സ്ഥാനം ലഭിക്കുന്നു, പക്ഷേ അതിലെ മൂല്യം ഒരു ഇന്റിജെറോ (integer)

will forward it to Professor X or Y or Z, according to who the current HOD is. So, this is a very useful concept and it can come in very, very handy, we will see examples

ഫ്ലോട്ടിംഗ് പോയിന്റ് (floating point) മൂല്യമോ കാരക്ടറോ (character) അല്ല, അത് ഒരു മെമ്മറി (memory) വിലാസമായിരിക്കും. ഈ മെമ്മറി (memory) വിലാസം, ഏതെങ്കിലും സ്ഥലത്തേക്ക്

of this later. But, as of now just remember that p is just like any other variable.

പോയിന്റു (point) ചെയ്യാമെന്ന് ചിന്തിക്കാം, നിങ്ങൾ *പി ചെയ്യുമ്പോൾ, വിലാസവും അത് എന്തിലേക്ക്

It gets a memory location, but the value in that is not an integer or a floating point

പോയിന്റ് (point) ചെയ്യുന്നു എന്നും , നിങ്ങൾക്ക് ലഭിക്കുന്ന മൂല്യം എന്താണ് എന്നും കാണിക്കുന്നു

value or a character, it is going to be a memory address.

. മറ്റേതൊരു വേരിയബിളിനെയും (variable) പോലെ ഒരു സമയം ഒരു വിലാസം മാത്രമേ

And this memory address, you can think of it as pointing to some location and when you

കൈവശം പി (p) യ്ക്കു വയ്ക്കാൻ കഴിയൂ, എന്നാൽ നിങ്ങൾക്ക് വ്യത്യസ്ത വിലാസങ്ങളിലേക്ക്

do star p, you are looking at the address and what it is pointing to and from there,

വ്യത്യസ്ത സമയങ്ങളിൽ പോയിന്റ് (point) ചെയ്യാൻ കഴിയും. അതിനാൽ, വേരിയബിളുകൾക്ക് (variable) വ്യത്യസ്ത സമയങ്ങളിൽ

what is the value that you get.

വ്യത്യസ്ത മൂല്യങ്ങൾ ഉണ്ടാകുന്നത് പോലെ,

So, just like any other variable p can hold only one address at a time, but you can point to different addresses at different times.

ഒരു പോയിന്റർ വേരിയബിളിന് (pointer variable) വ്യത്യസ്ത സമയങ്ങളിൽ വ്യത്യസ്ത വിലാസങ്ങൾ ഉണ്ടാകാം. ഞാൻ പോയിന്റർ (pointer) മൂല്യം 100 ൽ നിന്ന്

So, just like variables can have different values at different times, a pointer variable

250 ആക്കി മാറ്റുന്നുവെന്ന് നമുക്ക് പറയാം., അതിനുശേഷം

can have different addresses at different points of times.

ഇത് ഒരു പുതിയ സ്ഥാനത്തേക്ക് 250 ലേക്ക് നയിക്കാം, *പി (*p) ഇപ്പോൾ 84 ആയിരിക്കും , 38 അല്ല.

So, let us say I change the pointer value from 100 to 250.

ഇത് മനസിലാക്കാൻ, എൽ വാല്യൂ ( l value) , ആർ

I change p from taking the value 100 to 250, then it can point to a new location 250 and

വാല്യൂ (r value) എന്ന് വിളിക്കുന്ന ഈ ആശയം അറിയുന്നത് ഉപയോഗപ്രദമാകും. എനിക്ക് ഒരു വേരിയബിൾ (variable) k നൽകിയിട്ടുണ്ട്,

star p would now be 84 and not 38.

l വാല്യൂ ( l value) മെമ്മറി (memory) സ്ഥാനത്തിന്റെ

So, to understand this, it may be useful to know this concept of what is called l value

വിലാസത്തെ സൂചിപ്പിക്കുന്നു. അതിനാൽ, ഇടത് വശത്ത് l വാല്യൂ ( l value) ഉപയോഗിക്കുന്നു,

and r value. Let us say, I am given a variable k, the l value refers to the address of the memory

ഞാൻ k എന്ന് പറയുമ്പോഴെല്ലാം അത് യഥാർത്ഥത്തിൽ ഒരു നിർദ്ദിഷ്ട മെമ്മറി (memory) സ്ഥാനമാണ്, അതാണ്

location. So, l value is used on the left side, so whenever I say k, in turn it is actually a specific memory location, that is the l value and the r value is the actual value that you are going

l വാല്യൂ ( l value) , r വാല്യൂ (r value) നിങ്ങൾ ഇടാൻ

to put in.

പോകുന്ന യഥാർത്ഥ മൂല്യം.

So, if I say k equals x plus y, then x plus y is going to be a value and the value of

അതിനാൽ, K എന്നത് x + y യ്ക്ക് തുല്യമാണെന്ന് ഞാൻ പറഞ്ഞാൽ, x + y ഒരു മൂല്യമാകുകയും ഇതിന്റെ

this is going to be stored in k. So, the value of x plus y is the r value and the address of k is the l value.

മൂല്യം k ൽ സംഭരിക്കുകയും ചെയ്യും. അതിനാൽ, x+y യുടെ മൂല്യം r വാല്യൂവും (r value) k

So, pointers are actually allowing you to manipulate the l value.

യുടെ വിലാസം l വാല്യൂവുമാണ് (l value). അതിനാൽ, l വാല്യൂ (l value)കൈകാര്യം ചെയ്യാൻ

You always have expressions on the right side, you get the r value always, but pointers are

പോയിന്ററുകൾ (pointer) നിങ്ങളെ അനുവദിക്കുന്നു. എല്ലായ്പ്പോഴും വലതുവശത്ത് എക്‌സ്‌പ്രഷനുകളുണ്ട് (expression), എല്ലായ്പ്പോഴും r വാല്യൂ ലഭിക്കും

mechanism by which you actually can get access to the l value also.

(r value), പക്ഷേ പോയിന്ററുകൾ (pointer) നിങ്ങൾക്ക് യഥാർത്ഥത്തിൽ l വാല്യൂവിലേക്ക് (l value) ആക്‌സസ് (access) നേടാനാകുന്ന

So, pointers are themselves variables that store the address of the memory location and

സംവിധാനമാണ്. പോയിന്ററുകൾ (pointer) സ്വയം മെമ്മറി ലൊക്കേഷന്റെ (memory location) വിലാസം സംഭരിക്കുന്ന വേരിയബിളുകളാണ്

the memory required by a pointer depends upon the size of the memory in the machine.

(variable), കൂടാതെ ഒരു പോയിന്ററിന് (pointer) ആവശ്യമായ മെമ്മറി (memory) മെഷീനിലെ (machine) മെമ്മറിയുടെ (memory)

So, for instance let us say I have a pointer of size 8 bits or 1 byte; it can only point

വലുപ്പത്തെ ആശ്രയിച്ചിരിക്കുന്നു. ഉദാഹരണത്തിന് എനിക്ക് 8 ബിറ്റ് (bit) അല്ലെങ്കിൽ 1 ബൈറ്റിന്റെ (byte) വലുപ്പമുള്ള ഒരു പോയിന്റർ (pointer) ഉണ്ടെന്ന് പറയാം; ഇതിന് 256 വ്യത്യസ്ത

to 256 different locations.

സ്ഥലങ്ങളിലേക്ക് മാത്രമേ പോയിന്റ്

But, if I have a pointer of 2 bytes in size, it can point to 64000 or 64K locations, so

(point) ചെയ്യാൻ കഴിയൂ. പക്ഷേ, എനിക്ക് 2 ബൈറ്റുകളുടെ (byte) വലുപ്പമുള്ള ഒരു പോയിന്റർ (pointer) ഉണ്ടെങ്കിൽ, അതിന് 64000 അല്ലെങ്കിൽ

that is 65536 locations.

64 കെ (64k) ലൊക്കേഷനുകളിലേക്ക് പോയിന്റു (point) ചെയ്യാൻ

If it is four bytes, it can point to 4 gigabyte locations or 2 power 32 locations and so on.

കഴിയും, അത് 65536 ലൊക്കേഷനുകളാണ് (location). ഇത് നാല് ബൈറ്റുകളാണെങ്കിൽ (byte), ഇതിന് 4 ജിഗാബൈറ്റ്

So, let us see how to declare a pointer variable.

(4 gigabyte) ലൊക്കേഷനുകളിലേക്കോ (location) 2 പവർ 32 (2 power 32) ലൊക്കേഷനുകളിലേക്കോ

You precede the name, so p is the variable name and you precede a variable name by this

(location) പോയിന്റ് (point) ചെയ്യാം . ഒരു പോയിന്റർ വേരിയബിൾ (pointer variable) എങ്ങനെ ഡിക്ലയർ (declare) ചെയ്യുമെന്ന് നോക്കാം.

mark called asterisk (*) or a star right and before that you have the data type.

p എന്നത് വേരിയബിൾ (variable) നാമമാണ്, അതിനുമുമ്പ് ഈ നക്ഷത്രചിഹ്നം (*) അടയാളം ഉപയോഗിക്കുന്നു , അതിനുമുമ്പ് ഡാറ്റാ ടൈപ്പ് (data type) ഉണ്ട്.

So, there are three things that go with the pointer variable, you have the data type,

അതിനാൽ, പോയിന്റർ വേരിയബിളിനൊപ്പം (pointer variable) മൂന്ന് കാര്യങ്ങളുണ്ട്, നിങ്ങൾക്ക് ഡാറ്റാ ടൈപ്പ് (data type) ഉണ്ട്, നക്ഷത്രമുണ്ട്, വേരിയബിൾ

you have star and you have the variable name.

(variable) നാമവുമുണ്ട്. അതിനാൽ, p എന്നത് വേരിയബിളിന്റെ (variable) പേരും അവിടെയുള്ള

So, p is the name of the variable and the star symbol there, informs the complier that

നക്ഷത്ര ചിഹ്നവും, ഒരു പോയിന്റർ വേരിയബിൾ (pointer variable) വേണമെന്ന് കംപൈലറിനെ അറിയിക്കുന്നു,

we want a pointer variable, it should not be an integer p, it should be a pointer p

അത് ഒരു ഇന്റിജെർ (integer) p ആയിരിക്കരുത്, അത് ഒരു പോയിന്റർ (pointer) p ആയിരിക്കണം,

which means, you are going to store addresses in them and not integer values and the compiler

അതിനർത്ഥം നിങ്ങൾ അവയിൽ വിലാസങ്ങൾ സംഭരിക്കാൻ പോകുന്നു. കംപൈലർ (compiler) വിലാസം സംഭരിക്കാൻ നിങ്ങൾ

will set aside, how many ever bytes you want to store the address. And this thing int before that says, we intend to use this pointer to point to integer values.

ആഗ്രഹിക്കുന്ന ബൈറ്റുകൾ (byte) മാറ്റിവയ്ക്കും. ഇന്ററ്‌ (int) എന്നത് ഈ പോയിന്റർ (pointer) ഇന്റിജെർ (integer) മൂല്യങ്ങളെ പോയിന്റ് (point) ചെയ്യാൻ ഉപയോഗിക്കുന്നു എന്നാണ് . നിങ്ങൾക്ക് ഫ്ലോട്ടിംഗ് പോയിൻറ്

So, you could have floating point values and so on, in which case you need a floating point

(floating point) മൂല്യങ്ങളും മറ്റും ഉണ്ടായിരിക്കാം, ഈ സാഹചര്യത്തിൽ നിങ്ങൾക്ക് ഒരു ഫ്ലോട്ടിംഗ് പോയിൻറ് പോയിന്റർ (floating point pointer) ആവശ്യമാണ്.

pointer. So, let us see what the contents of the pointer variables are.

പോയിന്റർ വേരിയബിളുകളുടെ (pointer variable) ഉള്ളടക്കങ്ങൾ

So, there is a small piece of code here on the left side.

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

So, int k equals 38 which means, there is a variable called k, whose values is going to be 38 and you have int star p and this int star p, so I have int k equals 38 which

ഉണ്ട്. int k = 38 അതായത്, k എന്ന വേരിയബിൾ (variable) ഉണ്ട്, അതിന്റെ മൂല്യങ്ങൾ 38 ആകും, നിങ്ങൾക്ക് int * p ഉം ഉണ്ട്, എനിക്ക് ഒരു ഇന്റിജെർ വേരിയബിൾ

ഉണ്ട് (integer varaible) k, int *p എന്നത് p എന്ന് വിളിക്കുന്ന

means I have an integer variable called k, int star p is a pointer variable called p

ഒരു പോയിന്റർ വേരിയബിളാണ് (pointer variable), തുടർന്ന്

and then we are going to do some operations later.

നമ്മൾ പിന്നീട് ചില പ്രവർത്തനങ്ങൾ ചെയ്യാൻ

So, let us see what this means.

പോകുന്നു. അതിനാൽ, ഇതിന്റെ അർത്ഥമെന്താണെന്ന്

So, int k equals 38, what does that do? The compiler sees that k is an integer of data type integer.

നമുക്ക് നോക്കാം. അതിനാൽ, int k 38 ന് തുല്യമാണ്, അത് എന്താണ് ചെയ്യുന്നത്? K എന്നത് ഇന്റിജെറാണെന്നു (integer) കംപൈലർ (compiler) കാണുന്നു.

So, k is a variable of data type integer, so it gives you a memory location.

ഇത് നിങ്ങൾക്ക് ഒരു മെമ്മറി (memory) സ്ഥാനം നൽകുന്നു. ഈ സാഹചര്യത്തിൽ, പ്രോഗ്രാം (program) ഭാഗത്ത് നിന്ന് ഇത് 100 ആണെന്ന് ഞാൻ അനുമാനിക്കുന്നു,

In this case, I am assuming that it is 100 from the program side, we are going to call

ഇതിനെ k എന്ന് വിളിക്കാൻ പോകുന്നു, സംഭരിച്ചിരിക്കുന്ന

it k and the value that is stored is 38.

മൂല്യം 38 ആണ്. ഇത് നിങ്ങൾക്ക് ഇതിനകം

So, this is something that you already know.

അറിയാവുന്ന കാര്യമാണ്.

Now, let us look at the next line int star p.

ഇനി നമുക്ക് അടുത്ത വരി int *p നോക്കാം.

So, p is a variable name, so every variable gets a memory location, so p gets a memory location.

p എന്നത് ഒരു വേരിയബിൾ (variable) നാമമാണ്, ഓരോ വേരിയബിളിനും (variable) ഒരു മെമ്മറി (memory) സ്ഥാനം

In this case, I am assuming that it is 200, but what type is p, p is of the type int star

ലഭിക്കുന്നു, അതിനാൽ p ന് ഒരു മെമ്മറി (memory)

or it is a pointer to integer. So, int star p is a pointer to integer as of now, I do not have anything to initialize

സ്ഥാനം ലഭിക്കുന്നു. ഈ സാഹചര്യത്തിൽ, ഇത് 200 ആണെന്ന് ഞാൻ അനുമാനിക്കുന്നു, എന്നാൽ p പൂർണ്ണസംഖ്യയിലേക്കുള്ള പോയിന്ററാണ് (pointer).

അതിനാൽ, ഇന്റ് സ്റ്റാർ പി (int *p) എന്നത് ഇപ്പോൾ

here, so initially it is a unknown value for p, next statement says p equals ampersand

മുതൽ പൂർണ്ണസംഖ്യയിലേക്കുള്ള ഒരു പോയിന്ററാണ് (pointer), എനിക്ക് ഇവിടെ ഇനിഷ്യലായ്സ് (initialize) ചെയ്യാൻ ഒന്നുമില്ല, അതിനാൽ തുടക്കത്തിൽ

of k.

p ന് അജ്ഞാതമായ ഒരു മൂല്യമാണ്, അടുത്ത

So, the meaning of ampersand(&) of k is give the address of k, not the contents of k, give

സ്റ്റേറ്റ്മെന്റ് (statement) പറയുന്നത് p=& k. ആമ്പർസാൻഡിന്റെ (&) അർത്ഥം k യുടെ വിലാസം

the address of k and what is the address of k, it is 100.

നൽകുക, k ന്റെ ഉള്ളടക്കമല്ല, k ന്റെ വിലാസം നൽകുക,

So, when you say p equals ampersand k, p gets the value 100.

k ന്റെ വിലാസം 100 ആണ്. p=&k എന്ന് പറയുമ്പോൾ,

Remember, it is not 38 it gets 100 at this point, you can imagine that p is pointing

p ന് 100 മൂല്യം ലഭിക്കുന്നു. ഓർക്കുക, ഇത് 38 അല്ല, ഈ സമയത്ത് 100 ലഭിക്കുന്നു,

to the address of k and when you say star p equals 5, it means take p which is at location

p എന്നത് k യുടെ വിലാസത്തിലേക്ക് പോയിന്റ്ചെയ്യുന്നുവെന്നും (point) *p=5 എന്നതിന്റെ അർത്ഥം 200 സ്ഥാനത്തുള്ള പി എടുക്കുക എന്നാണ്.

200. It is supposed to be a pointer which is 100 and star p is the contents pointed to by 100,

ഇത് 100 എന്ന ഒരു പോയിന്ററും (pointer) *p 100 സൂചിപ്പിച്ച ഉള്ളടക്കങ്ങളുമാണ്, അത് ഇപ്പോൾ 38 ആണ്. ഇത് 5 ആയി മാറ്റുക എന്ന് പറയുന്നു,

which is now 38. It says change it to 5, so star p is 38, change it to 5, so let us do this once more.

അതിനാൽ * p 38 ആണ്, ഇത് 5 ആയി, നമുക്ക് ഇത് ഒരിക്കൽ കൂടി ചെയ്യാം. p സ്ഥാനം 200 ലാണ്, * p = 5 എന്ന് നിങ്ങൾ പറയുമ്പോൾ,

So, p is at location 200, when you say star p equals 5, you first go to location 200 and

നിങ്ങൾ ആദ്യം സ്ഥാനം 200 ലേക്ക് പോയി അവിടെയുള്ള മൂല്യം എന്താണെന്ന് കണ്ടെത്തുക.

find out, what is the value there. The value is 100 and star p means the value that is pointed 2 by p, which is currently

മൂല്യം 100 ഉം *p എന്നാൽ p പോയിന്റ് (point) ചെയ്യുന്ന മൂല്യം, അതായത് നിലവിൽ 38 ഉം ആണ്. അതിനാൽ, നിങ്ങൾ

38. So, you take 38 and you want star p to be 5 which means, this 38 should be change to

38 എടുക്കുകയും *p = 5 ആകണമെന്ന് ആഗ്രഹിക്കുകയും ചെയ്യുന്നു, അതായത് ഈ 38 5 ആയി മാറ്റണം. അതിനാൽ, ഇത് 100 നെ 5 ആക്കി മാറ്റുന്നില്ല,

5. So, it is not changing this 100 to 5, it changing this 38 to 5.

ഇത് 38 നെ 5 ആക്കി മാറ്റുന്നു. അതിനാൽ, k ലഭ്യമായ സ്ഥാനത്തേക്ക് പോയിന്റർ

So, if the pointer is still pointing to location at which k is available.

(pointer) ഇപ്പോഴും പോയിന്റ് (point) ചെയ്യുന്നു. അതിനാൽ, ഈ ഘട്ടത്തിൽ നമ്മൾ k പ്രിന്റു

So, at this point if we go and print k, k will actually have the value 5 and not 38,

(print) ചെയ്യുകയാണെങ്കിൽ, k ന് യഥാർത്ഥത്തിൽ 5 എന്ന മൂല്യമുണ്ടാകും, 38 അല്ല, കാരണം k വിലാസം

because k is address 100 and you used p to manipulate the value at address 100. So, I have a small program here which shows this in more detail. So, there are two integers, a and b, a currently holds the value 10 and b currently holds the

100 ഉം വിലാസം 100 ലെ മൂല്യം കൈകാര്യം ചെയ്യാൻ p ഉപയോഗിച്ചു. എനിക്ക് ഇവിടെ ഒരു ചെറിയ പ്രോഗ്രാം (program) ഉണ്ട്, ഇത് കൂടുതൽ വിശദമായി കാണിക്കുന്നു.

value 5 and this int star ip (*ip) is a pointer.

a, b എന്നീ രണ്ട് സംഖ്യകളുണ്ട്, നിലവിൽ a യുടെ മൂല്യം 10 ഉം b യുടെ മൂല്യം 5 ഉം int * ip ഒരു പോയിന്ററുമാണ്.

So, ip is an integer pointer and currently it is uninitialized, so at this point you

(pointer) അതിനാൽ, ip ഒരു ഇന്റിജെർ പോയിന്ററാണ് (integer pointer), നിലവിൽ ഇത് ഇനിഷ്യലായ്സ് (initialize)

can imagine that a and b are two locations, so I am going to do a small diagram on the

ചെയ്തിട്ടില്ല, അതിനാൽ ഈ ഘട്ടത്തിൽ a, b എന്നിവ രണ്ട് സ്ഥാനങ്ങളാണ്. ഞാൻ വലതുവശത്ത് ഒരു ചെറിയ ഡയഗ്രം (diagram)

right side.

ചെയ്യാൻ പോകുന്നു.

So, a is some location, let us assume that it is 100 and ‘a’ equals 10, we will put

A ഒരു സ്ഥാനം ആണ് അത് 100 ആണെന്നും 'എ' 10 ന്

10 at location 100, ‘b’ is a another variable let us say this is at location 105 and it

തുല്യമാണെന്നും നമുക്ക് 10 സ്ഥാനത്ത് 100 ഇടാം, 'ബി' മറ്റൊരു വേരിയബിളാണ് (variable),

is going to take a value 5 and ‘ip’ is a pointer variable. Let us say, this is at location 211 and since there is no initialization, there is unknown

ഇത് 105 ലൊക്കേഷനിലാണെന്നും (location) അത് എടുക്കാൻ പോകുന്നു മൂല്യം 5 ഉം 'ip' ഉം ഒരു പോയിന്റർ വേരിയബിളും (pointer variable) ആണ്. ഇത് ലൊക്കേഷൻ (location) 211 ലാണ്, ഇനിഷ്യലൈസേഷൻ

value here, it is unknown.

(initialization) ഇല്ലാത്തതിനാൽ, ഇവിടെ അജ്ഞാത മൂല്യമുണ്ട്,

Let us look at the first statement here, ip equals ampersand of a.

അത് അജ്ഞാതമാണ്. ഇവിടെ ആദ്യത്തെ സ്റ്റേറ്റ്മെന്റ് (statement) നോക്കാം, ip=&a.

So, ampersand of ‘a’ is the address of a, so what is the address of a?

‘a’ ന്റെ ആമ്പർസാൻഡ് (&) a യുടെ വിലാസമാണ്,

It is 100. So, this will contain the value 100, and then let us look at the printf statement here.

അതിനാൽ a യുടെ വിലാസം എന്താണ്? ഇത് 100 ആണ്. അതിനാൽ, ഇതിൽ 100 എന്ന മൂല്യം

So, it says print a print, print ip and print star ip.

അടങ്ങിയിരിക്കും, തുടർന്ന് നമുക്ക് ഇവിടെ പ്രിന്റ് എഫ് സ്റ്റേറ്റ്മെന്റ് (printf statement) നോക്കാം.

These are three things, we are going to print.

a പ്രിന്റ് (print) ചെയ്യുക, ip പ്രിന്റു (print) ചെയ്യുക,

So, what would print a give us?

*ip പ്രിന്റു (print) ചെയ്യുക.

It will give us the value 10 itself, because all the variables when you access them, you

ഇവ മൂന്ന് കാര്യങ്ങളാണ്, അച്ചടിക്കാൻ പോകുന്നത്. a പ്രിന്റ് (print) ചെയ്യുമ്പോൾ മൂല്യം 10 തന്നെ നൽകും,

directly get the value and what you get for ip.

കാരണം എല്ലാ വേരിയബിളുകളും (varaible) ആക്സസ് (access) ചെയ്യുമ്പോൾ

So, here we are also printing ip.

നേരിട്ട് മൂല്യം ലഭിക്കും. ഇവിടെ ip അച്ചടിക്കുന്നു.

What would be the value of ip?

ip മൂല്യം എന്തായിരിക്കും?

Ip should give you 100; because 100 is the address stored in ip and star ip is the content

ip നിങ്ങൾക്ക് 100 നൽകണം; കാരണം 100 എന്നത് ip യിൽ സംഭരിച്ചിരിക്കുന്ന വിലാസമാണ്, കൂടാതെ ip യിൽ സംഭരിച്ചിരിക്കുന്ന വിലാസത്തിന്റെ ഉള്ളടക്കമാണ്

of the address that is stored in ip that is the way to interpret it.

*ip ,. Ip- ൽ സംഭരിച്ചിരിക്കുന്ന വിലാസത്തിന്റെ ഉള്ളടക്കങ്ങൾ

Star ip is give me the contents of the address that is stored in ip. So, the address that is stored in ip is 100, the contents of 100 is 10.

*ip എനിക്ക് തരുന്നു. ഐപിയിൽ സംഭരിച്ചിരിക്കുന്ന വിലാസം 100 ആണ്, 100 ന്റെ ഉള്ളടക്കം 10 ആണ്. അതിനാൽ, ഈ പ്രിന്റ്

So, this printf statement is expected to print 10.

എഫ് സ്റ്റേറ്റ്മെന്റ് (printf statement) 10 അച്ചടിക്കുമെന്ന് പ്രതീക്ഷിക്കുന്നു.

It is expected to print 10 here, it is expected to print 100 and it is expected to print 10

നമുക്ക് ഈ വരി നോക്കാം, അടുത്ത വരി പറയുന്നു * ip *ip 4 ന് തുല്യമാണ്, അത് എന്താണ് ചെയ്യുന്നതെന്ന് നമുക്ക് നോക്കാം, എന്താണ് *ip? Ip പോയിന്റ് ചെയ്യുന്ന വിലാസത്തിലെ ഉള്ളടക്കങ്ങൾ

here, as well.

4 ആക്കി മാറ്റുക.

Then, let us look at this line, the next line says i star ip equals.

അതിനാൽ, ip ഇപ്പോഴും 100 ലേക്ക് പോയിന്റ് ചെയ്യുന്നു, അതിലെ ഉള്ളടക്കങ്ങൾ ഇപ്പോൾ

So, star ip equals 4, let us see what that does, so star ip, what is star ip?

യഥാർത്ഥത്തിൽ 10 ആയിരിക്കണം, അത് 4 ലേക്ക് മാറ്റണമെന്ന്

So, it says change the contents of the address that is pointed by ip to 4.

അത് പറയുന്നു. അതിനാൽ, ip ചൂണ്ടിക്കാണിച്ച ഇൻറിജർ പോയിന്ററിന്റെ (integer pointer) ഉള്ളടക്കങ്ങൾ 4 ലേക്ക് മാറ്റണം.

So, ip is still pointing to 100, the contents of that should be is actually 10 now, it says

അതിനാൽ, നിങ്ങൾ 100 നോക്കുക, 100 ഇപ്പോൾ a യിലേക്ക് പോയിന്റ് (point) ചെയ്യുന്നു. നിങ്ങൾ അത് 4 ലേക്ക് മാറ്റാൻ ആഗ്രഹിക്കുന്നു. ഈ പ്രിന്റ് എഫ് സ്റ്റേറ്റ്മെന്റ് (printf statement), നിങ്ങൾ അത്

change that to 4. So, contents of the integer pointer pointed by ip should be changed to 4.

4 ആക്കി മാറ്റിയതിനാൽ, *ip 4 ആയിരിക്കുമെന്ന് നിങ്ങൾ പ്രതീക്ഷിക്കുന്നു, a സ്ഥാനം 100 ൽ ആണ്, a

So, you go here, you look at 100, 100 is pointing to a now. So, 100 is pointing to a and you want to change that to 4. So, this printf statement, so since you have changed that to 4, you would expect star ip

=% d. ഇത് ഒരു മൂല്യം പ്രിന്റു (print) ചെയ്യേണ്ടതാണ്, ഇത് ഇപ്പോൾ 4 ആയിരിക്കും, ip ഇപ്പോഴും വിലാസം 100 ആണ്, നിങ്ങൾക്ക് 100 അവിടെ വേണം, ip മാറ്റിയിട്ടില്ല.

അതിനാൽ, ഇത് ഇപ്പോഴും 100 ആണ്, *ip ഇപ്പോൾ ip യിൽ

to be 4, but what happens because of that is, since a is in location 100, this a equals percentage d.

അടങ്ങിയിരിക്കുന്ന വിലാസം എടുക്കുന്നു, പോയിന്റർ (pointer) 4 ന്റെ മൂല്യം കണ്ടെത്തുന്നതിന് പോയിന്റർ (pointer) പിന്തുടരുക. അതിനാൽ, ഇതും 4 പ്രിന്റു (print) ചെയ്യും, അതിനാൽ

This is supposed to print the value of a, this will now be 4, ip is still address 100

*ip യും a യും ഒരേ മൂല്യം ആണ്, നമുക്ക് ip =&b ഉണ്ട്,

you want 100 there, ip has not changed. So, this is still be 100 and star ip is now take the address contained in ip, chase that

നമ്മൾ ഇപ്പോൾ ip യുടെ മൂല്യം തന്നെ മാറ്റുകയാണ്.

pointer find out the value that pointer is 4. So, this will also print 4, so star ip and a contain the same value, so, so far so good. Now, let us see what happens, because of this statement.

ip ഇപ്പോഴും 211 സ്ഥാനത്താണ് ഉള്ളത് , ip =&b, ഇപ്പോൾ 100 എന്നതിനുപകരം നിങ്ങൾക്ക് &105 ഉണ്ടാകും.

We have ip equals ampersand of b, we are now changing the value of ip itself.

ഇത് 105 ആയിരിക്കും, അതിനാൽ നിങ്ങൾ 100 മാറ്റി 105 ആക്കി.

So, ip still resides at location 211 and you have ip equals ampersand of b.

ഇപ്പോൾ, നിങ്ങൾ ഒരു പടി പിന്നോട്ട് പോയി ചിന്തിക്കുകയാണെങ്കിൽ, *ip എന്തായിരിക്കണം?, നമുക്ക് *ip നോക്കാം, *ip p യുടെ ഉള്ളടക്കം

So, instead of 100 now you will have ampersand of b that is 105.

അതായത് 105 എടുക്കുന്നു സ്ഥാനം 105 ൽ സൂക്ഷിച്ചിരിക്കുന്ന മൂല്യം 5 ആണ് . ബി ഇതിനകം 5 ആണ്, ip ഇപ്പോൾ 105 ഉം

So, this will be 105, so you over wrote 100 with 105.

*ip 105 എന്ന വിലാസത്തിലെ ഉള്ളടക്കവുമാണ് അതായത് 5. ഈ പ്രോഗ്രാമിൽ (program ) പുതിയതായിട്ടുള്ള

Now, if you take a step back and think about, what star ip must be?

ഒരു കാര്യം, % d എന്നതിന് പകരം % p എന്ന് വിളിക്കുന്ന

So, let us look at star ip, star ip is take the contents of p which is 105 and find out

ഈ ഫോർമാറ്റ് സ്‌പെസിഫയർ (format specifier) ഉപയോഗിച്ചു. %d എന്നത് പൂർണ്ണസംഖ്യകൾക്കും % p എന്നത് പോയിന്റർ ഡാറ്റ ടൈപ്പ് (pointer data type) അച്ചടിക്കുന്നതിനുമാണ്.

the value that is stored in location 105 that should be 5.

ഈ കാര്യം പ്രവർത്തിപ്പിക്കാൻ പോകുന്ന ഒരു ചെറിയ

So, b is already 5, ip will now have 105 and star ip is the contents of the address 105

പ്രോഗ്രാം (program) നമുക്ക് നോക്കാം. എനിക്ക് ഇവിടെ അതേ പ്രോഗ്രാം ഉണ്ട്, a, b എന്നിവയ്‌ക്ക് പകരം അതിനെ ഇവിടെ കൗണ്ട് (count) ഉം നമ്പറും (number) എന്ന് വിളിക്കുന്നു.

that is 5. So, one thing that is new in this program is, we have used this format specifier called

count=10 number = 5, നമുക്ക് ഇത് കംപൈൽ (compile) ചെയ്ത് പ്രവർത്തിപ്പിക്കാം. അതിനാൽ, ഇവിടെ എന്താണ് സംഭവിക്കുന്നതെന്ന് നിങ്ങൾ ശ്രദ്ധിക്കണമെന്ന് ഞാൻ ആഗ്രഹിക്കുന്നു.

percentage p instead of percentage d.

തുടക്കത്തിൽ count 10 ന് തുല്യമാണ്, നമുക്ക്

So, percentage d is meant for integers and percentage p is meant for printing the pointer

ഈ ലൈൻ നമ്പർ (line number) നോക്കാം. അതിനാൽ, ഈ വരി പ്രിന്റ് കൗണ്ട് , പ്രിന്റ്

data types. So, let us see a small program which is essentially going to run this thing. So, I am going to look at pointers exercise.

ഐപി, പ്രിന്റ് സ്റ്റാർ ഐപി (print count ip *ip) എന്നിവ പറയുന്നു. കൗണ്ട് (count) 10 ആണ്, ഐപി (ip) പൂജ്യങ്ങളാണ്, അതിനുശേഷം 2, 3, fe , 5, 4.

So, I have the same program here, so instead of a and b, it is called count and number

ഇത് യഥാർത്ഥത്തിൽ ഒരു വിലാസമാണ്, എന്തുകൊണ്ടാണ്

here.

ഇത് എഫ് അച്ചടിക്കുന്നത് എന്നതിനെക്കുറിച്ച്

So, count equals 10 and number equals 5 and you have these things here.

വിഷമിക്കേണ്ട. ഇത് ഹെക്സാഡെസിമൽ ഫോർമാറ്റിൽ (hexadecimal

So, let us compile it and run it.

format) എന്തെങ്കിലും അച്ചടിക്കുന്നു. അതാണ് കൗണ്ടിന്റെ (count) വിലാസം, നമ്മൾ

So, I want you to pay attention to what is happening here. So, initially count equals 10, so look at this program here, so let us look at this

പ്രതീക്ഷിച്ചതുപോലെ *ip 10 ആണ്. Ip &count ആയതിനാൽ , *ip = 4 ആണ് , അതിനർത്ഥം നിങ്ങൾക്ക് ഇതിനകം ഉള്ള വിലാസത്തിന്റെ മൂല്യം മാറ്റുക, ഉള്ളടക്കങ്ങൾ 4 ആക്കി മാറ്റുക.

രണ്ടാമത്തെ വരിയിൽ നമുക്ക് കൗണ്ട് (count)

line number. So, this line is saying print count, print ip and print star ip.

4 ആണ് , ip ഒരേ വിലാസവും *ip 4 ഉം 15 ആം വരിയിൽ,

So, count is 10, ip is some zeros, followed by 2, 3, fe, 5, 4. So, this is actually an address, do not worry about why it is printing f and so on. So, it is printing something in hexadecimal format. So, that is the address of count and star ip is 10, as we expected.

ip നമ്പറിലേക്ക് (number) മാറ്റി, നമ്പറിന്റെ (number) വിലാസം മറ്റേതെങ്കിലും വിലാസമാണ്, ഇത് 2, 3, f , 5, 0, ആണ് 5, 4 അല്ല. ip 2, 3, f 5, 0 ആയി മാറ്റിയതായി

So, because ip is ampersand of count, then we have star ip equals 4, which means change the value of the address that you already have, change the contents to 4.

നിങ്ങൾക്ക് കാണാം. മൂല്യം 5 ഉം *ip വഴി നിങ്ങൾക്ക് യഥാർത്ഥത്തിൽ ഒരേ മൂല്യം 5 ഉം ലഭിക്കും.

എ, ബി എന്നിവയ്ക്ക് പകരം ഈ പ്രോഗ്രാമിന്

So, in the second line we can see, count is also 4, ip is the same address and star ip

(program) കൗണ്ടും (count) നമ്പറും (number) ഉണ്ട്. അതിനാൽ, എന്താണ് സംഭവിക്കുന്നതെന്ന്

is 4 and in line number 15, we changed ip to point to number instead and numbers address

മനസിലാക്കാൻ ഈ വിശദീകരണവും അവിടെയുള്ള പ്രോഗ്രാമും (program) നിങ്ങളെ സഹായിക്കുന്നു. ഒരു ചെറിയ പോയിന്റ് (point) ഇത് സി (C) യിലെ

is some other address, it is 2, 3, fe, 5, 0 and not 5, 4.

പല പുതിയ പ്രോഗ്രാമർമാരും (programmer) തെറ്റിക്കുന്നത് മൂല്യങ്ങൾക്ക് അനുവദിക്കുന്ന മെമ്മറിയുടെ (memory)

So, you can see that ip changed to 2, 3, fe, 5, 0.

കാര്യമാണ്. ഒരു പോയിന്റർ (pointer) ഡിക്ലയർ (declare) ചെയ്താൽ

The value is 5 and through star ip, you actually get the same value 5. So, instead of a and b this program has count and number.

മൂല്യത്തിന് മെമ്മറി (memory) അനുവദിക്കുന്നില്ല, ഞാൻ എന്താണ് ഉദ്ദേശിക്കുന്നതെന്ന് വിശദീകരിക്കാം. എനിക്ക് int *p എന്ന് ഒരു ഡിക്ലറേഷൻ (declarartion) ഉണ്ട്.

എനിക്ക് ഡാറ്റാ ടൈപ്പ് (datatype) ഇൻറിജർ പോയിന്ററായ

So, hopefully this explanation and the program there, helps you in understanding what is

(integer pointer) p എന്ന വേരിയബിൾ (variable) ലഭിക്കും.

happening. So, one minor point and this is something that many novice programmers in C mess up is the actual notion of memory allocated to values.

അത് 200 ലൊക്കേഷനിലാണെന്ന് (location) നമുക്ക് പറയാം. ഇനിഷ്യലൈസേഷൻ (initialization) ഇല്ല, എനിക്ക് p യുടെ

So, declaring a pointer does not allocate memory for the value, so let me explain what I mean by that.

മൂല്യം അറിയില്ല. അതാണ് നിങ്ങൾ ഇവിടെ കാണുന്നത്. ഇവിടെ ഒരു ഡാഷ് ഡാഷ് (--) ഉണ്ടെന്ന് നിങ്ങൾ

Let us say, I have int star p, so I have a declaration called int star p.

കാണുന്നു, ഇനിഷ്യലൈസേഷൻ (initialization) ഇല്ല, ഞാൻ ഈ

What this is supposed to do is, I am going to have a variable called p, which is of the

* p =4 ചെയ്യുന്നു. ഇത് എന്താണ് ചെയ്യേണ്ടത്?

data type integer pointer. Let us say that is at location 200. Since, I have no initialization I have no known value of p.

ഇത് അജ്ഞാത മൂല്യത്തിലേക്കുള്ള ഒരു സ്ഥലമാണ്, ഈ *ip

So, that is what you see here.

പറയുന്നത് p ൽ സംഭരിച്ചിരിക്കുന്ന വിലാസം എടുക്കുക,

So, here you see that there is a dash dash, there is no initialization and let us say,

ആ പോയിന്റർ (pointer) പിന്തുടരുക, മൂല്യം 4 ലേക്ക് മാറ്റുകയോ

I do this star p equals 4.

മൂല്യം 4 ആക്കുകയോ ചെയ്യുക.

What is this supposed to do?

എന്നാൽ, ഇത് അജ്ഞാതമായതിനാൽ, നിങ്ങൾ ഇത് അജ്ഞാതമായി

This is a hither to unknown value and this star ip is saying take the address stored

എടുക്കുക, മറ്റൊരു ലൊക്കേഷനിൽ (location) പോയി, അത് 4 ലേക്ക് മാറ്റുക.

in p, chase that pointer and initializes the value to or change the value to 4.

അതിനാൽ, ഇത് അജ്ഞാതമായ ചില വിലാസങ്ങളിലേക്കാണ് വിരൽ ചൂണ്ടുന്നത്, ഈ അജ്ഞാത വിലാസത്തിന് മൂല്യം 4 ഉണ്ടായിരിക്കണമെന്ന് നിങ്ങൾ ആഗ്രഹിക്കുന്നു,

But, since this is unknown, you are saying take this unknown, go to some memory location

ഇത് സി (C) യിലെ നിയമപരമായ പ്രവർത്തനമല്ല.

I do not know which and change that to 4.

അതിനാൽ, ചില ഘട്ടങ്ങളിൽ നിങ്ങൾ p എടുത്ത്

So, this is pointing to some unknown address and you want this unknown address to have

അതിൽ സാധുവായ ഒരു വിലാസം ഇടേണ്ടതാണ്, അതിനുശേഷം മാത്രം , നിങ്ങൾക്ക് *p ആക്സസ്

the value 4, this is not a legal operation in C. So, at some point you have to take p

(access) ചെയ്യാൻ കഴിയും. അതിനാൽ, കാര്യങ്ങളുടെ ശ്രേണി എന്താണെന്ന് നമുക്ക് നോക്കാം, &p 200 ആണ്, കാരണം p ന്

and put a valid address in it and only then, you will be able to access star p.

ഒരു മെമ്മറി (memory) സ്ഥാനം നൽകിയിട്ടുണ്ട്, കംപൈലർ (compiler) അത് ചെയ്യും, കാരണം ഇത് ഒരു വേരിയബിൾ

So, let us see what the sequence of things are, ampersand of p is 200, because p is given

(variabel) ആണ്, നിങ്ങൾക്ക് സ്ഥാനം 200 ലഭിക്കും. എന്നിരുന്നാലും p തന്നെ അജ്ഞാതമാണ്,

a memory location, compiler will do that because it is a variable, you will get location 200. However p itself is unknown, so we access the variable p, you get the contents of this

അതിനാൽ നമ്മൾ p എന്ന വേരിയബിൾ (variable) ആക്സസ് (access) ചെയ്യുന്നു, നിങ്ങൾക്ക് ഈ സ്ഥാനത്തിന്റെ ഉള്ളടക്കം 200 ലഭിക്കും. ഇത് അജ്ഞാതമാണ്, അതിനാൽ *p നിയമവിരുദ്ധമാണ്.

location 200. This is unknown and therefore, star p is illegal.

ഇതോടെ മൊഡ്യൂൾ (module) 2 അവസാനിക്കുകയാണ്, കൂടാതെ മൊഡ്യൂൾ (module) 3, 4 എന്നിവയിൽ, പോയിന്ററുകളുമായി

So, this brings us to the end of module 2 and in module 3 and 4, we will look at various

(pointer) ബന്ധപ്പെട്ട മറ്റ് പല സൂക്ഷ്മതകളും നമ്മൾ പരിശോധിക്കും. പോയിൻററുകൾ‌ (pointer) സ്വന്തമായി ഒരു പ്രശ്‌നമായി

other subtleties related to pointers. We will not only see pointers as a problem of it is own, but we will also see, how to

നമ്മൾ കാണില്ല, പോയിൻററുകൾ (pointer) എങ്ങനെ ഉപയോഗിക്കാമെന്നും അറേ എങ്ങനെ ആക്‌സസ് (access) ചെയ്യാമെന്നും ആക്‌സസ് (access) ചെയ്യുന്നതിന് പോയിന്റർ‌ (pointer) ഉപയോഗിക്കുമ്പോൾ

use pointers and access arrays and what are the different issues that come up, when we

വരുന്ന വിവിധ പ്രശ്നങ്ങൾ‌ എന്താണെന്നും നമ്മൾ

use pointer to access arrays. So, you have reached the end of the module 2, we will see these things in modules 3 and 4. Thank you.

കാണും. അതിനാൽ, നിങ്ങൾ മൊഡ്യൂൾ (module) 2 ന്റെ അവസാനത്തിലെത്തി, നമ്മൾ ഇവ 3, 4 മൊഡ്യൂളുകളിൽ (module) കാണും.