Advanced Fortran Programming : 029 : Pointers and Applications Video Lecture | Introduction to Fortran Programming (AdvancedLevel) - Database Management

hello guys my name is Aaron and welcome
to my channel this series is a series of
you tour it's an advanced Fortran
programming now in this tutorial we will
be looking at the pointed data
operations available in Fortran now what
is a pointer now pointer is actually a
datatype it stores the address of other
data type okay now this may be a little
confusing I will explain again what is a
pointer to see pointer is just like just
like all other data types it is another
data type okay now what it does is that
instead of storing some value like some
variable value and stuff okay what it
does is that it stores the value okay it
stores the address of some other value
okay you know what it does is now
because of that because of that it has
access to that variables address as well
as the value okay now enough of me
explaining that I'll explaining that
guys in a simple way you guys can
understand see look at this function the
program declaration over here okay see
this variable x1 and these these are
variables x1 x2 these are integers okay
they each have their own value okay now
P 1 and P 2 P 3 P 4 these four well
variables are integers the same time
these four are actually pointers okay
now the thing is p1 is associated with
x1 ok they are linked P 1 X 2 X 1 are
linked together so what p1 does is that
it stores the address where the address
location of X 1 P 2 is as it is X 2 so
it stores the address value of x 2
similarly P 3 stores the address of X 3
and P P 4 again because of this comment
it stores the address of X 3 again so
what happens is that P 1 and P 1 since
it stores the address of X 1 ok it can
also access the value of x 1 similarly P
2 cans stores address of X 2 and it also
accesses now it can also access the
value
of x2 likewise p3 and p4 also that's the
same so now there's a point you have to
keep in mind okay see as far as
foreigners cons concerned maybe I
fathered any point any language for that
for that matter any language for that
matter okay
a pointer can only point to a single
variable okay whereas a variable can
have many pointers it's like this okay
a credit card or a debit card okay has
only one user okay whereas one user can
have multiple debit cards or multiple
credit cards simple as that okay just
like that URL so you can also say this
is another way just like how a house has
just one owner okay you know always have
one owner but a person can have multiple
houses like that this is how it goes
available has only how can have many
pointers pointing to it whereas a
pointer can have only one variable
pointing pointed by it okay that's the
simple explanation because of that okay
p1 if it is already pointing x1 it
cannot point to other variables like X 2
or X 3 whereas X 3 can be pointed by p3
same time P for any possible p1 and also
by P and also by p2 so the thing is
variables can have any variable can have
infinite number of pointers but a point
a pointer can have only one variable at
the at an instant without getting it
modified okay
now let's see some regulations and stuff
as to how pointers can be made okay now
this module part is just ignore this for
a moment I'll explain you guys this in a
minute okay now if you want to write if
you want to make a pointer make a
pointer and use a point in your program
there are there are two conditions you
have to satisfy number one the variables
that you are for which you want the
pointers to be associated with should
have and should man the company should
have the keyword target
No if this if this keyword target is
absent then these variables cannot be
pointed to by the pointers that's the
kind of a general rule that's kind of a
rule in Fortran which you have to follow
second okay and if you want to declare a
pointer okay all I ever do is that after
the data type you just add this keyword
pointer pointer and that's it
once you do that then it's simple then
it's fixed then what you can do is that
that pointers are ready to point towards
certain variables that's it and this
another guy another kind of an implicit
rule caras a zeroth root meaning it's
kind of the basic rule what does what
does this say is this data type as for
the pointer as well as the variable
should be the same if you want them if
you want to mix and match
they do not work and also because of
this rule the size of the variable size
of the pointer and the target should
also be I mean pointer and the variable
should also be the same at least on the
same order that's what it that's what I
mean okay I'll explain this in this
example see the real value are the real
dimension array are one okay which it is
this actually it's a three dimensional
array with ten rows ten columns and ten
pages whichever you call it a ten
Heights which I recall it or ten levels
okay okay
all of these values all of its values
are set to the value eight okay and now
if you want pointer to r1 okay I real
valid pointer to r1 then the pointer
should also be real because this is real
the dimension it need not be 10 plus 10
plus 10 but even if it's 10 question
question I think it doesn't matter what
it should be is that it should have they
should have a row column and as well as
a level it should it should be three
dimensional that's it the size of it it
doesn't matter because it gets allocated
automatically according to the pointer
sizes get allocated accordingly to the
size of the variable is getting pointed
to so it's three dimensional okay the
dimension should match that's more
important the value of the value of the
dimension need not be this
need not be the same but the order of
the dimension should match so this is
like a third three-dimensional matrix so
this binder is again a three dimensional
three dimensional pointer so dimensions
are matching so they'll work fine okay
suppose if we have a two dimensional
matrix matrix then the point should also
be two dimensional if it's one
dimensional the pointer should be one
that which is put zero dimensional like
these the pointer should also be C 2
dimensional so these are the four roots
the datatype should be the same the dye
number diamond the number of dimensions
should also be the same okay the
variables to whom you want to punch
should have the attribute target the if
you want to make a variable a pointer
key is the keyword pointer and then how
to associate them see thing is we told
the beginning of the day in the
beginning of this tutorial I told that
pointers store the address of a variable
okay now how do we make sure that you
know one pointer is associated with the
variable it's simple
Fortran allows this allows this
operation using this compound the symbol
equal to greater than equal to greater
than so if you write p1 equal to greater
than x1 what it actually means is that
you are linking the point of p1 with x1
ok now this is how you call linking now
the reason why they use this is because
it's something similar to an arrow right
at with an arrow facing the arrow head
facing towards the right okay it's like
that so p1 is actually pointing towards
excellence by its definition point it so
it's acting like a pointer so it's
intuitively speaking until speaking is a
pointer that's why they give this symbol
that's why they get a symbol equal to
equal to greater than so it's
intuitively sure see you can't read you
see that it's Pawnee towards x1 that's
the reason okay
now that being said this is how you make
the point this is how we make the
pointing okay so this is our you know
point pointer to a target okay like that
P 2 star because of this P 2 is pointing
towards X 2 and P 3 is pointing towards
X 4 now to show that you know X 4
integer X 4 over here
not have a pointer okay you got cannot
have monitor let's come let's I'm coming
the statement and run this ok cx4 does
not have the Stargate attribute so it
behaves as a normal variable so if so
this cannot be pointed to towards it can
be pointed to now let's see this if I
were to compile this
it throws an error state in the compiler
throws an error stating that error
pointer assessment tag it is neither
target nor pointer so it means you
cannot point it means you cannot point
towards X 4 so this statement is not
possible on the other hand for the sake
of curiosity let's see whether you can
point let's see whether you can point P
4 to P 3 meaning I'm using a pointer to
point to an another pointer which again
is pointing the words in our other
variable let's see this is possible
compile this yes apparently yes it works
ok forgot to compile build and run this
yes it works I'll explain you guys about
this a minute so meaning for a pointer
can point to another pointer a pointer
can point another pointer so this is
valid so this is valid though we're not
using it this is valid and then let's
see if you cut back to the previous
statement P 4 is equal to greater than X
3 okay
now to show that P 3 is pointing towards
X 3 and P 4 is pointing towards X 3 to
show that both of them have rights over
it I have rights over it ok we will see
this example we will see how is
overriding and stuff happens I'll show
how this happens okay now if Z
110 X 2 is 25 whereas X 3 is it doesn't
have any value it yet ok X 4 will not be
used in the program so far not be used
in the program and let's see P 3 and P 4
associated with x 3 + PT i underscore R
1 is asserted with R 1
now what I do is that I set P 4 to
before fight now that's funny
now P 4 is already of the pointer now
how can store a value let's see what
does this mean if I said P 4 to Phi okay
and then and then I am just you know
copying this this I'm just copying this
printing this on the top printing this
on the top and then I'll copy this as
well
okay and then I'm copy copy P P 3 as
well okay I should have copied these
three are simultaneously fine now
with this let's see what happens if I
were to compile just throw the warning
stating that makes first not use that's
okay build and execute this okay now
watch now what this is the first print
statement if I said P for to be 5 X 3
becomes automatically fight no that's
funny because I didn't make a dent said
X 3 Phi right now how does this possible
this is because the pointer when you
setup an you to the pointer it
automatically sets the value of its
variable as well we already told you the
definition right pointers can access the
values of it however is a variable
itself like that like that okay now
because of this okay since P 3 is also
since I assume all hit P 4 over here P 3
is also pointing towards X 3 okay
now if P 3 the value of P 3 okay v3 will
point towards X 3 so you never had to
print the value of P 3 it'll it'll print
the value it's it finds an X 3 so which
is again fight because before such the
value of x 3 to P Phi so P 3 when you
print the value P 3 okay it just gets
the value from X 3 and printed assert
becomes Phi and then P 4 is 5 source
as it is now what happens is that now
let me print let's look at these since X
1 and X 2 are predefined ok let's see
the value of P 1 and P 2 as well so if X
1 is 5 X 1 is 10 P 1 is again turn quite
natural X 2 is 25 P 2 is 25 quite
natural and now what I've done here is
that as reset the value of P 3 now P 3
what I've done is that I said P 3 to be
255 now let's see how this works if I
said after I said this these six
statements get executed now if ever had
to come over here since P 3 stood the
255 it what it does is that it also
access it also modifies the value of the
term X 3 the variable X 3 so because of
which X 3 becomes 255 P 3 becomes 255
and P 4 also becomes 255 so this is a
clear cut indication that you know
pointers know that the multiple pointers
pointing to the same variable have equal
rights to modify the variable content so
this also this is an advantage as well
as a disadvantage that Vantage is that
if you want to you have multiple
variables pointer variables are normal
variables to available for the same
memory location in the same memory
location to express so instead of if I
want to use X 3 I can instead of X they
can use the pointer name itself and so
on okay that's an advantage disadvantage
is that I have to be very very cautious
as to how the data types are used how
the dimeric variables are matching
suppose if I were to conserve the value
and you know in some process is I'm
going to p3 or p4 you use the point is
directly what happens is that one change
changing the value are modifying the or
using one pointer and manipulating its
value can manipulate the value of other
point at the value of the other pointer
as well as the memory so I had to be
very very cautious in that regard
ok that's it and now that's that's the
that's the that's this part and now
looking at the next thing is that real
pointer now let's look at this
three-dimensional pointer I said PT and
this I said are 1 to b8 throughout in
this matrix and so what
they have PT and the score are one to be
point into it's our one okay now if I
print r1 1 comma 1 comma 6
it prints to be 8 okay and Pt underscore
R 1 is again 1 comma 1 comma 1 comma 6
is again 8 so there are the replace this
and write any other and Ickes it will
also be the same he'll also in the
pointer was the same that value asset of
r1 so far the same index that is okay so
so what I have here is that I have a
pointer which accesses the value of r1
so instead of r1 I can use speed he had
a square R 1 instead of it's in
something like a representative for
minor can act as a representative for
the variable that's it ok now let's look
at an important concept called as
associativity okay now I'll let I listen
to keep this bash script along bash
shell along with it but I said along
with it because this will be useful to
look at ok I'll explain what
associativity means see see we say that
p1 is pointing towards X 1 B 2 is party
towards X 2 this is a solidity meaning
p1 there's a connection between X B 1
and because of this pointer expression P
1 and X 1 are connected because of this
pointer expression P 2 and X 2 are
connected because of these two
expressions this expression and this
expression this follow my cursor this
expression and this expression P 3 P 4 X
3 Erika are associated with each other
ok now what to check whether a pointer
is acid with the variable ok especially
when you have a large large number of
pointers and variables by playing a role
in the program ok it might be necessary
to have a function okay now that
function together to check whether there
are link to link to each other or not is
called as Association associated ok once
names are so what it does is that if you
just pass a pointer inside it just pass
a pointer inside it it will say whether
the pointer is a pointing to us if the
pointer is pointing toward some variable
okay it will return true the point is
now a point is not pointing towards any
variable it will
turn thoughts okay okay
similarly if you pass a pointer as well
as a variable okay this is the answer
will be true if that pointer is pointed
towards that variable the answer would
be first when these two are not pointed
to these two are not associated okay and
then these are all the permutation and
combination of all the results okay and
these are the palmdale and if you want
to cancel the association between a
pointer and it's variable okay there is
a simple way to do that and that and
that is called as nullify okay this
function nullify what it does is that it
cancels the oxidation between the
pointer and the variable okay now
because of this nullify p21 you know we
here what it does is that just
completely nullifies the connection
between the point of p2 and the value
but the value of x2 will be safe and
intact okay only the pointer is
nullified and it's point does not limit
but the value of x2 will remain as it is
and safe so what is this is the after
null if I'm just an ally thank Pete over
here at peak and the score I'll run over
here so after nullification if I were to
write that to see how things go by x1 x2
are 10 and 25 as mentioned above and 24
if you look at the value of x2 which is
25 same as previous sonal affiliation of
p2 does not modify extra so that that
may your point to this nullified my
third and my odd modifying the value it
by it was pointing to also P you
understand okay p2 0 okay
p2 0 so point this pointers work has
been neglected and it's made 0 and then
r1 is 8 that's okay and but if I were to
print PTFE TR underscore R 1 R 1 of 1
comma 1 comma 6 it'll throw me it will
throw a segmentation fault errors
because this pointer has been deleted
deleted nullified because of this
nullify stuff LSI keywords oh if you
have to uncomment this and run this
you'll get a segmentation fault error so
just guys have to look at that
that's not a big deal and because of the
if you guys notice and the top here p1
and extra and associated so it's true P
1 and X 2 are not associate P 1 X 1 a so
it's true this is al is true P 1 and X 2
are not associated so it returns false P
2 and X 2 are associated it's true and P
2 and X 1 are not as I said it so it
returns false okay like that this is how
it goes now let's check few more stuff
control D Association of p1 let's see
let's see the variables are associative
let's see the very much associated yeah
this is a problem Association works for
pointers and point and variable combo
but not the variable because variables
are not the pointers okay so this does
not work so I'll just comment this out
and then there's not that's not work so
if ever to compile this yeah it's
working fine compare this this one this
doesn't work okay I guess because of
this I guess this was I guess this will
this will work work with it now because
of this you have an advantage of
pointers I have an advantage of pointers
for brindis of pointers okay now mostly
for scientific computation with Fortran
only for only in specific cases they use
pointer arithmetic but in most of the
cases as far as my understanding was
pair as far as I've looked at it yeah
they don't use pointers but Toyotas are
the writers are quite useful but for but
on a large scale people don't use
pointers in Fortran so that's you have
to keep that in mind so it's just a
fancy thing to look at okay and one more
thing the last topic for today in this
tutorial is that pointers are very very
useful for creating lists data
structures or linked linked lists or
something of that
okay now what is a linked list is some
is I'll explain this as a follows okay
no I will explain this in the pictorial
format okay and after when I've
explained this pictorial form and I'll
explain this module part I learned and
you'll get an idea of what's going on
see okay forgive me for my extremely
crap crap if extremely crappy drawing
skills okay I do not I do not have a
tablet or I do not have any pointed
stylus to draw this nicely I just have
to draw this with my mouse so it's a
little copy but forgive me okay let's
say you just have a data type something
like this okay like like this you create
the Revelator type of name itself some
name okay which has a certain set of
values so it's a kind of so it's a
structure it has had in set of values
okay and along with it the same data
type it has a point of PT okay okay so
what it does is that you have a
structure with a lot of lot of variables
in it
the same time our pointer cons
corresponding to the same structure fine
okay now let me represent one such
derided a type variable as n1 okay n1 is
one there are data type of certain type
okay
I have stands for all the variables in
it and P stands for the pointer now what
do you do is that I set all the values
of the variables as input of this
variable I as some inputs and then using
the pointer using the pointer and n1
what I do is that I associated with this
with around on the delay data type of
the same type and - okay now P P will
this P of N 1 will point towards all the
variables I okay of data type and - ok
and this will this will have a data type
this will have again a pointer P which
will point towards all the variables in
n 3 n 3 ok and this will also have a
pointer which will point towards all the
variables in and for
which laughs pointed at the points to
identify and so on and so forth you can
go on so what do you have here is that
one derive data type is linked towards
another data type and which is again
linked to another data type and so on
and so forth so it's something like a
list so these are linked and it's linear
so one connect to the other an account
or other other kind to another without
any crisscross matching and stuff so
this is a linear so this is aadi this is
linear in nature and it's linked and it
kind of hounds a list because after one
one one one set of values for a B on
others at the values followed by another
set of values so you have a like a list
like feature going on so this is what we
call as a linear linked structure a
linear linked data structure or list
data structure okay this is a linear
linked data structure so well these are
kind of very much useful for you know
doing a lot of job especially in appliqu
especially for making applications and
operating systems and all for instance
let me go to this files C let me open
something see if I go to my computer
okay just for a thought okay home okay
just go to home my folder okay but the
problem the thing is this will be inside
home okay inside this root there will be
multiple folders over here and each of
the folders will point to us and
subfolders inside and each of them will
have subfolders inside and each other
will have subfolders inside and so on
and so forth so what you have is that is
that one set of data okay instead of
just single pod you have multiple point
is over each party towards one thing but
if it did just take one fold ends
another it'll have already how is that
you just have a hierarchy kind of a
thing this is very much useful for
operating system kind of stuff which we
looked at okay this is called as a
linear link structure this is one
example but there are other examples as
well that can be explained with and
other is other s something called as
circular less circular linked lists
circular linked lists what it does is
simple
see here in green link
the last the last pointer variable is
actually set to null meaning it's that's
meaning that you're terminating it over
here but instead if I were to point this
if they if I were to find this pointer
to the to the variables of the data data
type variable n1 what will happen what
will happen is something as this this n1
will have the way it will have its own
variables and it'll be point and with
the pointer in it will be pointing
towards the variables of n2 whose
pointer will be pointing towards the
variables n3 and whose pointer will
point it was available to anyone so it
what happens is that you have a chain
each of them are linked towards each
other so this is concerning called as a
circular list a circularly linked list
okay there can be no I mean I'm not sure
whether there are nonlinear linked lists
or not I'm not sure about it but this is
again a linked list it's circular
okay if you want to form this kind of
stuff what do you need is a set of
variables and a pointer and in this I
simplify if you want to make a
simplified data data type and simplify
data data type to work all this is like
this
okay you need one variable and you can
have multiple variables like that
doesn't matter and one point of and what
you do is that my create multiple
variables of the day of this type okay
and point one to the other one pointer
to the other another party brother or
the final pointer to were null and go
and go like that so this way you can
create a singly linked list and then
I'll explain there's another concept
another kind of thing you can do with
these okay
the which is pair pretty much applicable
to you know the file processing
management in any operating system see
this computer okay as this is this is
the addresses actually addresses
actually if you can see just the slash
key if I were to go to home I forgot the
carpus control yeah like this okay boom
the address is home okay they got their
you know addresses
route home and in that if I go to my
$400 over here through route home I
don't fold onto turns and then you have
so much links so at the same time we go
to my computer that's not the only
process now that's not the only thing
your home is multi gearing divided into
multiple places like SRV media mounted
stuff so what happens is that you have a
certain kind of data type wherein you
have multiple pointers each each
branching out like each branching out
and each of these branches have multiple
data types multiple the multiple point
does each pointing towards a certain
other fault like that so what do you
have is that you just have something
like a link a linked list but it's
having multiple links and multiple
branches so so the integral speaking
this kind of thing looks like a tree and
that's what we're going to see this
means again forgive me for my horrible
drawing skills this is called as a tree
structure okay you have data type you
have some delay data type of variable a
here you store all the variables and
then let's say you have two branches two
pointers one pointer part was the left
point let's call this fork I mean for
simplicity sake let us call this as left
and this call the left point and this
call as a right pointer now this left
pointer can point towards another data
type of be rather than variable B and
this can point to another data type C
okay now each and a B has two pointers
and CS two pointers so we can add salt
so because of this because of this we
can take two more point two more
variables C can take two more variables
and turn in the next level you can take
eight more you can connect four level
four variables and the next level you
can connect eight where eight level
eight variables and the next level 16
variables and so on and so forth you can
branch it and suppose if we want to
block them what you can do is that you
can nullify them you can attach one of
the pointers to the null nullify the
pointers and thereby stop them and you
have nullifying pointers over here and
thereby you know you can just control
the number of branches
have okay this kind of stuff is pretty
much essential for another or file
management stuff in operating systems
and all and pointers in this digas are
very much useful in operating systems I
find is another stuff for other stuff
also if I may for making very large
applications and stuff okay
this is one of the examples of you know
lists these are one of the applications
of pointers
trust me if I'm not trust me I haven't
worked with linked lists or linear
linked lists or circular linked lists of
branches are trees in my life I haven't
worked with them I mean I never had a
use of it so I know but and the same way
I never learned about it on my own so I
can't a given X proper explanation
server to give that it's it will not be
you know proper justification to the
topic and it's a very interesting topic
to look at so if you guys if you guys
already have an advantage of linked
lists and all you you'll understand this
in a better and if you know if you guys
didn't have never used about this linked
list and how trees and linked lists and
all don't worry it's just console just a
concept just a very useful concept but
not so useful for normal applications
where is just useful for some specific
software based applications so you don't
have to worry about them you don't have
to worry about and that and these are
the hundreds called as trees and if the
tree in the trees if and in trees if one
if something these trees can also also
be called as binary trees because each
three each value has only two the
pointers that's so which you can take
only two values are the theme of this a
single time so these this can be called
as binary trees
suppose if your data type has three
pointers it can be a shady tree or
something ternary or quaternary three if
it has four piles like that and two if
you want to make if you want to make a
simple data type which is pointed like
that what you need is some data set of
characters and two pointers left and
right for a binary tree if you want the
Terminator II you can create left right
middle and something of that sort and so
on and so forth and this
okay that's it that's all I have for you
guys they guarding pointers and stuff
and thank you guys for watching and this
will be very interesting and useful
useful especially for the you know the
hard core programming hard core
programmers and stuff okay
thank you guys for watching and I'll see
you guys next tutorial and in the next
tutorial we'll be covering just one
we'll be covering two more topics and
with that we'll be ending up this
tutorial series thank you guys for
watching and I'll see you guys next
tutorial see ya