Here is a quickie demo of Pointers. I did it in a few minutes.
So its not very elaborate. Keep in mind for much more detailed
examples SWAG has 43 example codes and demo programs just to
be examined. For SWAG a link can be found on my programming
page links section @
http://users.cybermax.net/~longshot
------------
Program PTDem;
Uses Crt, Dos;
type StrArray = Array[1..5000] of String[70];
Begin
end.
------------
A basic, simple program. Let's try to create a large string array.
In this case however, the above will not work. It clearly
is too large (5000x70 = 350000 bytes when borland Dos IDE only
supports 64k for its Dos Platform programs). So this will not
compile. We have to correct the size to a more manageable size.
Program PTDem;
Uses Crt, Dos;
type StrArray = Array[1..800] of String[70];
Var ICnt : Integer;
SAR : StrArray;
Begin
For ICnt := 1 to 800 do
Begin
SAR[ICnt] := Chr(Random(65)+1);
Writeln(SAR[Icnt]);
End;
end.
-----------
The StrArray is now 800 elements but still length of 70. This
is much smaller but compiles to 56K of data. I create a simple
counter variable and then a new variable SAR. This StringArrayRecord
variable is of same type as Strarray. This is so we can access and
store/use the data. But if you compile the basic Type is only 688
bytes but with this new SAR variable the data size goes to 57490
which is still in the 64k limit but huge!
The For loop simply stores a random character in the SAR record
array (all 800 items). Then writes it to screen. Now this
will work but its still alot of space taken up.
BTW, I forgot we should put a RANDOMIZE; at the top before the
loop to make it truely random (I forgot).
------
Now comes the magic of pointers.
Program PTDem;
Uses Crt, Dos;
type StrArray = Array[1..800] of String[70];
Var Str_Pt : ^StrArray;
ICnt : Integer;
{ SAR : StrArray;}
Begin
New(Str_Pt);
For ICnt := 1 to 800 do
Begin
Str_Pt^[ICnt] := Chr(Random(65)+1);
Writeln(Str_Pt^[Icnt]);
End;
Dispose(Str_PT);
end.
1. Notice I commented out the SAR variable freeing up 57k of data.
2. The new part is Str_Pt which is a variable of pointer type.
This Str_Pt POINTS to StrArray. The Use of the ^ shows it
where its pointing to. Thus an arrow..pointer..get it?
3. When you compile this it saves and goes down to 694 bytes of data
space a BIG difference.
4. A new command New(Str_Pt); Is a constructor in OOP programming.
It Creates and reserves space for the pointer on the heap.
5. Same for Dispose at the bottom. This is a Destructor in OOP
jargon and clears the reservation of that spot so other programs
can use that memory space.
6. Now to use the pointers:
Str_Pt^[ICnt] := Chr(Random(65)+1);
Writeln(Str_Pt^[Icnt]);
The only difference here is we added a ^ to the end of the
variable. This means we are Storing data using the pointer
Str_PT. Then we read the same data using the ^ at the end as well
meaning we are retrieving info from the pointer.
It may be confusing as to where to put the ^ at the end or start.
Just remember for data access, writes, reads use it at the end.
For making varibles use it at the start so its pointing to some
variable. This is much clearer to read than it is in C/C++ language
and if you get in in pascal it helps alot.
So what does the above really do? Well it frees up that huge chunk
of ACTIVE memory to be stored Dynamically. This means the memory
for the data is stored in Ram be it EMS, XMS or the space between
the 64k limit and 1 meg of memory some old computers had :)
This is houw the 64k memory barrier is broken. But this doesn't
mean you have infinite space for data. It just meams you can
store as much data as you have in memory. Thus a good system
with 256 Megs of Ram could store a great, great deal of data.
But the larger you get the more management you have to do on the
data.
Management of the data is done through commands like GetMem (a
popular command used in simple graphics like PutImage for
example) which simply gets the amount of space needed for some
data object. FreeMem, AllocMem and other Heap commands also
become critical for large programs.
Pointers also speed up processing since its in memory rather
than on a physical data space which may take time. This
is another advantage of pointers.
The Heap is basically that area of memory that is used by
programs to Stack data (thus the Stack Size you see in your
compile screens).
Each function or procedure you do has a limited Stack space
of data they can substore data in. But all this can be
managed via pascal commands or the IDE itself. You can
set lower or max heap and stack sizes to use.
It is CRITICAL that you use a 1:1 association of New/Dispose.
If you have 8 Pointers you should have 8 News and 8 Disposes.
If not this will cause memory leaks. Thus when you exit
your program the data of the pointer will still be reserved
and not released so new programs you run can't use it. This
we have all seen sometimes through the evil Windows Blue
screen of death in some errors.
Does this help or confuse folks? I could explain more if needed.
Gotta run for now..
--- Fringe BBS
* Origin: EWOG II - The Fringe - 904-733-1721 (1:112/91)