Carson X-10NB Chassis User Manual download pdf (Page 72)

Pascal

Procedures

John

Jones

this column I'll give you a few

pointers on pointers. Actually, it'll be

than

a few pointers - we're

going

wade

right

into this non-

trivial subject.

you'll see, pointers

can be a very powerful tool,

but

a lot

of people

don't

use

them

because they

don't

understand them. We'll begin

looking

allocation of variables, and

then

we'll see

what

that

has

with pointers.

Static

& Dynamic Variables

Variables

declared

the

PRO-

GRAM section and in non-recursive

procedures are

static

variables. This

means their storage is allocated and

fixed

compile time. Two mecha-

nisms are built into Pascal for crea-

tion and use of variables

run

time

- recursive procedure calls and dy-

namic variables.

Procedures compiled with recursion

enabled will, when called, generate

new copies of their internal variables

the

recursion stack. On

return

from

the

procedure, their space is released

for other use. This is all

transparent

the

programmer and application.

Pointers

The other mechanism for run-time

variable allocation involves pointer

variables.

A pointer is a variable which con-

tains the address of a variable instead

the

data

itself. Pointers are

de-

clared

prefixing

the

pointer charac-

ter

('A

a variable type.

type

strarray

= array[O

••

str1ng[16];

1ntptr

~1nteger;

aryptr

~strarray;

var

dynint

1ntptr;

Pointers can be assigned and

com-

pared in much

the

same way as other

variables. The primary function of

pointers, however,

allow for

the

creation

and

use of dynamic variables.

Free memory is assigned

the

heap,

and this area is available for newly

created dynamic variables. The state-

ment:

new

(

dynint)

;

will create a variable of

type

INTE-

GER

on the heap, assign the integer's

address

dynint, and reduce

the

size

the

heap

one integer's storage

space.

dyn1nt--

....

dynint

Dynamic variables are accessed

using

the

pointer character as a suffix

the

pointer name. So

the

above

says

that

"dynint"

is the address

while

"dynint

the

value contained

the

address.

dynint

other1ntvar

dynint

;

Two

mutually

exclusive mecha-

nisms are used for

de~allocating

heap

space. Your compiler will have one or

both

of them.

dispose(dynint);

Dispose is

the

complement of New

and will do

what

its

name implies -

dispose of

the

storage for dynint .

The other method for reclaiming

heap space is called

"Mark"

and

lets you

mark

a variable so you can

reclaim

and everything beyond it.

Hark(dynint)

;

This places a marker on

the

heap

dynint

position. Later, when

the

statement: RELEASE(dynint) is exe-

cuted, all space allocated from

dynint"-

onward will be de-allocated.

your

compiler provides

both

methods, re-

sults will be unpredictable if you use

both

the

same program.

this

were

far as

the

story went,

dynamic variables would

not

be much

more useful

than

statics. Since point-

ers can point

records and can also

be fields of records, uses for dynamic

variables are limited only

the

imagination.

Linked

Lists

Given

the

following declarations,

type

6245 Columbia Ave.

St. Louis MO 63139

lstptr

= A11st1tem;

11st1tem =

record

itemdata

datatype;

nxt~tem

lstptr;

end;

var

root,

item

lstptr;

we can construct a simple linked

list. The pointer root

our anchor on

the world, and

points

the

start

the

list. The list is initialized with:

root

nil;

{nil

the

pre-

defined

value

for

null

pOinter

}

and

items

are

added

this

way:

and items are added in

this

way:

new('item); {

create

new

var

}

itemA.itemdata

data;

{

the

field

"itemdata"

record

pOinted

item

assigned

contents

data

}

itemA.nxt~tem

root;

{

link

prevo

data

}

root

item;

{

reestablish

anchor }

Singly linked lists

shown in

Figure 1 can be useful,

but

they

have

disadvantages. First,

the

components

can only be accessed serially from

the

previous item. Another disadvantage

that

insertions and deletions can be

cumbersome. Also, if you use a

list

like this, all procedures

that

access

must

be sure

check for an

empty

list.

The

First

Shall Remain So

using an additional reference

pointer

that

always points

the

oldest item, a

structure

called a queue

is formed.

See Figure

this

example, items are added

using the pointer

LAST, in a way

similar

the

above for a simple list.

The additional factor

consider is

that

the

initial item should be added

with

the

pointer

FIRST.

Removal of

items from this queue can be done as

shown in Figure

A queue is

thus

a first in, first

out

structure, while

the

earlier simple

linked list is a

last

in, first

out

device.

Micro Cornucopia, Number 25, August-September 1985

1 2 ... 67 68 69 70 71 72 73 74 75 76 77 ... 107 108

Comments to this Manuals

No comments

Carson X-10NB Chassis User Manual Page 72

Comments to this Manuals