Yapısal Türler

(Structured Types)

Yapısal türler, skalar türlere göre daha karmaşık bir yapıya sahiptirler. Bu türler ve bu türdeki değişkenler ayrıca "veri yapısı" olarak bilinir.

ARRAY

(Sonlu Diziler)

Array, aynı türden çok sayıda değişkeni birarada tutan bir yapıdır. Programcı tarafından tanımlanır. Matematikteki sonlu diziler gibidir. Her dizinin bir adı, dizinin öğeleri, öğelerin seçildiği küme (veri türü), her bir öğeyi diğerlerinden ayıran indisleri vardır. Array, programın ya da bir blokun bildirge bölümünde, dolaysız ya da dolaylı olarak bildirilebilir. Sözdizimi şöyledir:

Dolaysız bildirim

Var

Array_değişken_adı[indisler] : tür;

Dolaylı Bildirim

Type

array_tipi_adı = ARRAY[indisler] OF tür;

Var

array_değişken_adı : array_tipi_adı;

Bu bildirimde, array ve of sözcükleri saklı sözcüklerdir. Tür, derleyicide var olan (integer, char, real, boolean, ...) bir tür olabileceği gibi, programcının daha önce tanımladığı bir tür de olabilir. İndisler, ordinal bir kümenin bir alt bölgesi olmak zorundadır. Array’in öğelerinin her birisine öteki değişkenlerde olduğu gibi, ana bellekte yeterli birer yer ayrılır.

Var

Dizi : ARRAY[12..23] OF integer;

bildirimi, dizi adında, onüç öğesi olan bir array değişkeni tanımlar. Array’in öğelerini birbirinden ayıran indisler, integer veri türünün 12..23 alt bölgesidir; yani 12 den başlayıp 23 e kadar devam eden tamsayılardır. Dizinin öğeleri,

Dizi[12]

Dizi[13]

...

dizi[23]

dür.

Örnek

Type

Bolge = ‘D’..’H’ ;

dizi_tipi_1 = ARRAY[harfler] OF boolean;

Var

liste : dizi_tipi_1;

bildirimi, liste adında, beş öğesi olan bir array değişkeni tanımlar. Array’in indisleri, char ordinal veri türünün harfler adıyla bildirilen ‘D’..’H’ alt bölgesidir. Liste’nin öğeleri,

liste[‘D’], liste[‘E’], liste[‘F’], liste[‘H’], liste[‘G’]

dir.

Benzer array’ler arasında aktarma işlemleri topluca yapılabildiği için, programın farklı bloklarında, farklı adlarla kullanılacak arrayler dolaylı olarak tanıtılmalıdır. Ama programda, bir kez kullanılacak arrayleri dolaysız olarak tanıtmak uygun olur.

Örnek

Aynı tür diziler arasında aktarma işlemi yapılabilir. Örneğin

var

liste, sirano: array[1..3] of integer;

bildiriden sonra

liste[1] := 4;

liste[2] := 3;

liste[3] := 8;

deyimlerden sonra liste[1] 'in değeri 4, liste[2] 'nin değeri 3 ve liste[3] 'ün değeri 8 olur. Sirano := liste ataması, toplu atamadır ve

sirano[1] := liste[1];

sirano[2] := liste[2];

sirano[3] := liste[3];

atamalarına denktir.

Array öğelerine değer atama ve başka değişkenlerden değer aktarma ya da başka değişkenlere değer aktarma işlemleri yapılabilir. Atama ve aktarma işlemlerinde işlemler ve fonksiyonlar kullanılabilir:

Örnek

program array05;

uses wincrt;

type

kucuk_harfler = 'a'..'z';

buyuk_harfler = 'A'..'Z';

k_harf_dizisi = ARRAY[1..26] OF kucuk_harfler;

b_harf_dizisi = ARRAY[1..26] OF buyuk_harfler;

Var

kharf : k_harf_dizisi;

bharf : b_harf_dizisi;

kh, bh: char;

i : integer;

begin

kh := 'a';

bh := 'A';

write(kh);

for i := 1 to 25do

begin

kharf[i] := char(ord(kh)+i);

write(kharf[i] );

end;

writeln; writeln;

write(bh);

for i := 1 to 25do

begin

bharf[i] := char(ord(bh)+i);

write(bharf[i] );

end

end.

Aşağıdaki deyimler, array bildirimlerinin ve array öğelerine atama ve aktarma işlemlerinin çok esnek biçimlerde yapılabileceğini göstermektedir. Her deyiminin yaptığı işi tek tek düşününüz.

Type

meyve_tipi = (elma, armut, portakal, mandalina);

hafta_tipi = (PA,PT,SA,CA,PE,CU,CT);

meyve_dizisi = ARRAY[hafta_tipi] OF meyve_tipi ;

Var

meyve1, meyve2 : meyve_dizisi ;

bildirimi, önce “meyve_tipi” ve “hafta_tipi” adlı iki numaralanmış (ordinal) veri türlerini, sonra da, “meyve_dizisi” adlı bir array tanımlamaktadır. Arrayin öğeleri meyve_tipidir; yani elma, armut, portakal ve mandalina değerlerini alabilirler. Array öğelerinin indisleri “hafta_tipi” nden seçilecektir. Dolayısıyla, indisler, haftanın gunlerini gösteren PA,PT,SA,CA,PE,CU,CT simgeleridir. Arrayi temsil edecek meyve1, meyve2 adlı iki değişken tanımlanmıştır. Bu durumda, örneğin, meyve1’in öğeleri,

meyve1[PA], meyve1[PT], meyve1[SA], meyve1[CA], meyve1[PE], meyve1[CU], meyve1[CT]

Bu öğelere, doğrudan bir meyve tipinden değer verilebilir. Örneğin, çarşamba günü diyete konulacak meyveyi

Meyve1[CA] := portakal;

atama deyimiyle belirtebiliriz. Bu basit atama yöntemi yanında, sıralanmış veri türlerinde, pred ve succ fonksiyonlarının tanımlı olduğunu anımsarsak, aşağıdaki karmaşık atama ve aktarma deyimlerini de kullanılabileceğini söyleyebiliriz.

begin

Meyve1[CA] := portakal;

Meyve2[succ(PE)] := pred(meyve1[succ(SA)]);

mantik1[iyi] := (meyve2[pred(CT)]= armut);

writeln('meyve2[CU] = pred(meyve1[succ(SA)]) mı? ' ,mantik1[iyi])

end.

Aşağıdaki bildirimler, yukarıdaki indis kümesiyle veri türünün rollerini değiştirmektedir. Bu da, programcının ordinal ve yapısal veri türlerini tanımlamakta ne kadar serbest olduğunu gösterir.

Meyve_tipi = (elma, armut, portakal, mandalina);

hafta_tipi = (PA,PT,SA,CA,PE,CU,CT);

hafta_dizisi = ARRAY[meyve_tipi] OF hafta_tipi ;

Var

hafta1, hafta2 : hafta_dizisi ;

bildirimi, yukarıda olduğu gibi, önce “meyve_tipi” ve “hafta_tipi” adlı numaralanmış (ordinal) iki veri türünü, sonra da, “hafta_dizisi” adlı bir array tanımlamaktadır. Arrayin öğeleri hafta_tipidir; yani PA,PT,SA,CA,PE,CU,CT değerlerini alabilirler. Array öğelerinin indisleri “meyve_tipi” nden seçilecektir. Dolayısıyla, indisler, meyveleri gösteren elma, armut, portakal ve mandalina adlarıdır. Arrayi temsil edecek hafta1, hafta2 adlı iki değişken tanımlanmıştır. Bu durumda, örneğin, hafta1’in öğeleri,

hafta11[elma], hafta1[armut], hafta1[portakal], hafta1[mandalina]

Bu öğelere, hafta_tipi’nden değer atanabilir. Örneğin, portakalın Çarşamba gunu diyete konulacağını

hafta1[portakal] := CA;

atama deyimiyle belirtebiliriz. Tabii, yukarıda olduğu gibi, atama ve aktarma deyimlerinde işlem ve fonksiyonlar da kullanılabilir:

begin

hafta1[elma] := pred(PE);

hafta1[mandalina] := pred(hafta1[elma]);

hafta2[armut] := pred(hafta1[succ(portakal)]);

bayrak1 := (hafta2[armut] = PT);

writeln('hafta2[armut] = pred(hafta1[succ(portakal)] mı? ' ,bayrak1 );

End.

Aşağıdaki programın benzerlerini yazarak, array rürü tanımlamakta ve tanımladığınız array’in öğelerine atama ve aktarma yapmak için kullanabileceğiniz deyimlerinin esnekliğini görünüz.

program array (input,output);

uses wincrt;

Type

Meyve_tipi = (elma, armut, portakal, mandalina);

okul_donemi = 1990..2000;

hafta_tipi = (PA,PT,SA,CA,PE,CU,CT);

basari_tipi = (pekiyi, iyi, orta, zayif);

meyve_dizisi = ARRAY[hafta_tipi] OF meyve_tipi ;

basari_dizisi = ARRAY[okul_donemi] OF basari_tipi ;

hafta_dizisi = ARRAY[meyve_tipi] OF hafta_tipi ;

mantik_dizisi = ARRAY[basari_tipi] OF boolean ;

int_dizisi = ARRAY['c'..'e'] OF integer ;

kesir_dizisi = ARRAY[1..5] OF real ;

harf_dizisi = ARRAY[3..9] OF char ;

Var

meyve1, meyve2 : meyve_dizisi ;

okul1, okul2 : basari_dizisi ;

hafta1, hafta2 : hafta_dizisi ;

mantik1, mantik2 : mantik_dizisi ;

harf1, harf2 : harf_dizisi ;

sayi : int_dizisi;

kesir : kesir_dizisi;

m ,n, i : integer ;

x, y : real ;

bayrak1, bayrak2 : boolean;

begin

Meyve1[CA] := portakal;

Meyve2[succ(PE)] := pred(meyve1[succ(SA)]);

mantik1[iyi] := (meyve2[pred(CT)]= armut);

writeln('meyve2[CU] = pred(meyve1[succ(SA)]) mı? ' ,mantik1[iyi]);

writeln; writeln;

Okul1[1995] := pekiyi;

Okul2[1998] := succ(okul1[pred(1996)]);

mantik2[orta] := (okul2[1998]= iyi);

writeln('okul2[1998]= succ(okul1[pred(1996)] mi? ' ,mantik2[orta] );

writeln; writeln;

hafta1[elma] := pred(PE);

hafta1[mandalina] := pred(hafta1[elma]);

hafta2[armut] := pred(hafta1[succ(portakal)]);

bayrak1 := (hafta2[armut] = PT);

writeln('hafta2[armut] = pred(hafta1[succ(portakal)] mı? ' ,bayrak1 );

writeln; writeln;

harf1[3] := 'A'; harf1[4]:='N'; harf1[5]:='K';

harf1[6]:= harf1[3]; harf1[7]:='R'; harf1[8]:= harf1[3];

harf2 := harf1; {arrayin bütün öğelerini aktarır}

for i:=3 to 9 do

write(harf2[i]); writeln; writeln;

m := 25;

sayi['d'] := m;

sayi['e'] := sayi['d'];

n := sayi['e'];

writeln('n = ' , n);

writeln; writeln;

x := 17.4;

kesir[4] := x;

kesir[2] := kesir[4] * 23.6;

y := sayi['e'] + 3/kesir[4];

writeln('y = ' , y:10:3);

writeln; writeln;

End.

Uygun bildirimler altında, array’ler döngüler ve denetimler için oldukça uygun nesneler olur. Array öğeleri, kendi türlerinden değişkenlerle yapılabilen her işlemi yapabilirler.

Aşağıdaki deyimleri içeren küçük programlar yazınız.

(i) for i:=1 to 4 do d[i] := sqr(i);

(ii) diyet[pazartesi] := kayisi;

(iii) Derya[2] := 54;

(iv) case harf of

'A' : cevir[harf] := 'a';

'B' : cevir[harf] := 'b';

........................

'Z' : cevir[harf] := 'z';

end;

(v) for harf := 'A' to 'z' do

cevir[harf] := char(ord(harf)+ord('a')-ord('A'));

(vi) if (Demet[1] + Demet[2] + Demet[3]) >= 150 then

Writeln('Demet başarılı bir öğrencidir.')

else

Writeln('Demet sınıfta kaldı');

Bu tür örnekler kolayca çoğaltılabilir.

Dizilerin Ana Bellekte Tutulması

Bir dizinin öğeleri, ana bellekte ard arda saklanır. Arrayin adının adresi ile birinci öğesinin adresi (başlangıç adresi) aynıdır. Örneğin, yukarıdaki "d" dizisinin her öğesinin 8 bytlık bir alanda tutulduğunu düşünürsek, aşağıdaki geometrik temsili yapabiliriz.

| d[1] | d[2] | d[3] | d[4] |

----------------------------------------------------------------------------

| | | | | | | | | | | | | | | | | | | | | | | | | |

----------------------------------------------------------------------------

^ ^ ^ ^

d ve d[1] d[2] nin d[3] ün d[4] ün

nın adresi adresi adresi adresi

Her öğenin türü aynı olduğunda, her öğenin başlangıç adresi kolayca (Pascal derleyicisi tarafından) hesaplanabilir ve böylece bu öğeye direkt olarak oluşabilir. Yani d[i]'nin değerini okumak ya da ona yeni bir değer atamak için, önceden gelen öğelerinin okunması gerekli değildir. Böylece her öğe için ulaşım zamanı aynıdır ve çok kısadır. Bu tür erişime istemli (rasgele, random) erişim denilir. Yapısal veriler bu niteliğe sahiptir. Ama ileride göreceğimiz text file (yazı dosyası, yazı kütüğü) türü istemli erişimi sağlamaz; ona ancak sırayla erişilir. Başka bir deyişle, yazı kütükleri için okuma ve yazma işlemleri ancak baştan itibaren yapılabilir. Böylece belli bir öğeye erişim zamanı, kayıt ortamında o öğenin bulunduğu yere bağlıdır. Doğal olarak, bu tür erişim zamanı daha uzun olur. Bu tür erişime dizisel (sequential) erişim denilir.

Diziler bazı işler için çok kullanışlı olur. Örneğin bir tek array adı bildirimiyle, belli bir türden çok sayıda değişken yaratılabilir. Ayrıca indeks bir sayaç olarak kullanılırsa değer verme ve okuma için bir döngüler çok kolay kurulabilir. Öte yandan, dizininin her öğesi ana bellekte bir yer tutacağı için, gerçekten gerekli olduğu zaman kullanılmalıdır.

Aşağıdaki program, verilen sayıların standart sapmasını bulur.

Örnek

program StandartSapma(input, output);

uses crt;

type

VeriAra = 1..50;

var

Veri : array[VeriAra] of real;

Sayi, Toplam, Ort, StdSap : real;

Num, i : integer;

Cevap : char;

begin

repeat

clrscr;

writeln('Standart Sapma Programi':51);

writeln;writeln;

writeln('En fazla elli tane sifirdan farkli gercel sayi veriniz');

writeln('Veri listeniz sifir sayi ile bitiriniz');

writeln;

Num := 0;

Toplam := 0;

repeat

readln(Sayi);

if Sayi <> 0 then

begin

Toplam := Toplam + Sayi;

Num := Num + 1;

Veri[Num] := Sayi

end

until (Sayi = 0) or (Num = 50);

writeln;

if Num = 0 then

writeln('Ortalama ve Standart Sapma sifirdir')

else

begin

Ort := Toplam/Num;

Toplam := 0;

for i := 1 to Num do

Toplam := Toplam + sqr(Ort - Veri[i]);

StdSap := sqrt(Toplam/Num);

writeln('Ortalama = ', Ort:3:2,', Standart Sapma = ', StdSap:3:2)

end;

writeln;

write('Devam edelim mi? (E/H) : ');

repeat

read(Cevap);

Cevap := upcase(Cevap)

until Cevap in ['E','H']

until Cevap = 'H'

end.

Paketlenmiş Diziler (Packed Arrays)

Bazı bilgisayarlarda bir değişkenin adresi üzerinde bazı kısıtlamalar olabilir. Öreneğin bazı makineler veriyi ikişer byte şeklinde bellekten alır ve bu durumda değişkenleri çift adreslerde saklamayı tercih edebilir. Böyle bir durumda

c : array[1..5] of char;

dizimi aşağıdaki gibi saklanır.

2n 2(n+1)

| |

---------------------------------------

| | | | | | | | | | |

---------------------------------------

^ ^ ^ ^ ^

c[1] c[2] c[3] c[4] c[5]

Bu örnekte saklama ve okuma çok hızlı olduğu halde ekonomik değildir. "Packed" (Paketlenmiş) saklı sözcük yardımı ile daha ekonomik bir saklama şekli elde edilir:

2n 2n+1 pc : packed array[1..5] of char;

| |

--------------------------------

| | | | | |

--------------------------------

^ ^ ^

pc[1] pc[2] pc[5]

Bu tür saklamada, veriye ulaşım biraz daha yavaş olur, örneğin pc[2] 'yi elde etmek için pc[1] ve pc[2] beraber okunur ve pc[2] 'yi elde etmek için ikiye parçalanır.

Paketlenmiş diziler, normal diziler gibi kullanılır. Turbo Pascal'da tüm diziler "paketlenmiş" olur ve "packed" sözcüğünün bu bakımdan bir etkisi yoktur.

Standart Pascal'ın Metin Türü

(Packed Array of Char)

Hemen her programlama dilinde, metin (text) işlemek gerekir. PASCAL, yaratılış tarihindeki donanım olanaklarının kısıtlaması nedeniyle, metin işlemek için char türü array kullanmaktan başka bir olanak getirmemiştir. Daha sonra, bu durum değişmiş ve Pascal derleyicileri, metin işlemek için özel yordamlar getirmiştir.

Standart Pascal'da

packed array[1..N] of char;

yapısal veri türü, sabit uzunlukta char türünden dizileri saklamak için kullanılır. Bu, (paketlenmiş) bir dizi olduğundan, bunu temsil eden değişkene N bytlık bir yer ayrılır. Girilen metin, N den daha az harfe sahipse, artan hücreler boş kalır. N den fazla ise, fazla olanlar değişkene ayrılan yere sığmaz; atılır.

Değer atama

s : packed array[1..20] of char;

bildiriminden sonra 'Merhaba Dünya' metnini girmek için, ya bir döngü ile

s[1] := 'M'; s[2] := 'e'; ... ; s[13] :='a';

atamaları yapılır ya da

s := 'Merhaba Dünya';

ataması yapılır. Bu so atama yukarıdaki atamalara denktir. s 'nin uzunluğu 20 olduğu için “Merhaba Dünya” metni girildikten sonra 7 tane boş yer kalır. Bazı derleyicilerde, boş kalan kısımları ara tuşu ya da başka dolgu karakterleriyle doldurmak gerekir.

-----------------------------------------

|M|e|r|h|a|b|a| |D|ü|n|y|a| | | | | | | |

-----------------------------------------

Bazı Pascal sistemlerinde ise (Turbo Pascal dahil), boş kalan yerleri kullanıcının doldurması gerekmez, sistem kendiliğinden boşluk yaratır. Başka bir deyişle, 20 harflik değişken için 13 harflik

s := 'Merhaba Dünya';

atamasını yazmak yeterlidir. Yani, sondaki boşlukları tırnaklar arasında yazmamız gerekli değildir.

Sabit N (uzunlukta olan) char dizilerini tutan değişkenler için tam tamına N karakterlik bir yer ayrıldığı için, girilen metin uzunluğu ayrıca kaydedilmez. Örneğin,

'Merhaba Dünya' (uzunluk 13)

ve

'Merhaba Dünya ' (uzunluk 14)

değerleri aynı şekilde saklanır. Bu niteliğe dikkat edilmezse, program bazen istenmeyen sonuçlar verebilir.

Turbo Pascal'ın Metin Türü (String)

Turbo Pascal, metin işlemek için ise daha gelişmiş değişken uzunlukta olan

String[N]

veri türünü tanımlamıştır. String[N], türü de Packed Array[1..n] of char türü gibi, N den çok olmayan harften oluşan metinleri tutmaya yarar. Ama string[N] girilen metin uzunluğunu dinamik olarak kaydeder. Örneğin,

s : String[20];

bildiriminden sonra

s := 'Merhaba Dünya';

deyimi, standart pascaldaki gibi geçerli olur. Ama, ana bellekte, s değişkenine ayrılan adresin ilk hücresine, girilen metnin uzunluğu kaydedilir. Buna göre, ana bellekteki durum şöyledir:

0 1 2 20

-------------------------------------------

|#|M|e|r|h|a|b|a| |D|ü|n|y|a|?|?|?|?|?|?|?|

-------------------------------------------

ord(#) bu örnekte 13 olur. ? 'daki değerler belirsizdir. Adresin ilk hücresinde kayıtlı olan 0 'ıncı öğeyi (normal olarak) sadece Pascal sistemi kullanır. Bu nedenle, girilen metnin uzunluğunu veren "length" adlı bir fonksiyon vardır. Örneğin,

length(s) = 13

olur. length(s)=ord(s[0]) dir. Ayrıca, string[N] türünde, N sayısı 1 <= N <= 255 dir.

Karşılaştırma

Aynı uzunlukta olan iki char dizisi ya da Turbo Pascal'da herhangi iki string değişkeni karşılaştırılabilir. Karşılaştırma indislerin ordinal sayısı ve sözlük sıralaması kullanılarak yapılır. Bu iş, metin arama ve sıralamanın esasıdır.

Çok Boyutlu Array

Atematikte olduğu gibi, birden çok indise bağlı olan diziye çok boyutlu array denilir. Çok boyutlu array tanımı için, hepsi aynı işi yapan farklı sözdizim biçimlerini kullanabiliriz. Tek boyutlu array için olduğu gibi, çok boyutluları da dolaysız ya da dolaylı olarak tanımlamak mümkündür. Kısalığı sakınmak için dolaysız tanımı söylemekle yetineceğiz.

D1, D2, ..., DN numaralanmış birer küme ya da ordinal kümelerin birer alt bölgeleri olmak üzere, array arrayi (fonksiyon fonksiyonu) biçiminde tanımlayabiliriz.

Var

Array_adı : ARRAY[D1] OF ARRAY[D2] OF ... OF ARRAY[DN] OF tür;

bildirimi N boyutlu bir array tanımlar. Boyut sayısı kadar indis kümesi vardır. Örneğin,

Var

dizi : ARRAY[1..4] OF ARRAY[ ‘A’..’E’] OF integer;

bildirimi, 20 öğeli iki boyutlu bir dizi oluşturur. Bu dizinin öğelerini aşağıdaki tabloda gösterebiliriz.

dizi[1,’A’] dizi[1,’B’] dizi[1,’C’] dizi[1,’D’] dizi[1,’E’]

dizi[2,’A’] dizi[2,’B’] dizi[2,’C’] dizi[2,’D’] dizi[2,’E’]

dizi[3,’A’] dizi[3,’B’] dizi[3,’C’] dizi[3,’D’] dizi[3,’E’]

dizi[4,’A’] dizi[4,’B’] dizi[4,’C’] dizi[4,’D’] dizi[4,’E’]

dizi[5,’A’] dizi[5,’B’] dizi[5,’C’] dizi[5,’D’] dizi[5,’E’]

Aynı diziyi,

Type

satir = ARRAY[1..4] OF integer;

liste = ARRAY[‘A’..’E’] OF liste;

Var

Dizi : liste;

biçiminde ya da daha kısa olarak,

Var

Dizi : ARRAY[1..4 , ’A’..’E’] OF integer;

bildirimiyle tanımlayabiliriz.

Çok boyutlu arraylere erişim, tek boyutlu arraylerde olduğu gibidir.

Uygulamalar

1. Bir dizinin öğelerinin klavyeden girişini yapan bir procedür yazınız. [Yol gösterme: Klavyeden bir dizinin girişini yapmak için aşağıdakine benzer bir program parçası kullanılabilir.]

...............

const

uzunluk = 80; {arrayin öğe sayısı}

var

d : array[1..uzunluk] of char;

i : integer;

begin

i := 0;

While (not eoln) and (i < uzunluk) do

begin

i := i + 1;

read(d[i]);

end;

readln; {Satır sonunu geçmek için}

. . . . . . . . . . . . . .

end.

Girilen öğelerin ekranda görünmesini isterseniz,

for j := 1 to i do

Write(d[j])

biçiminde bir döngü komanız yetecektir.

2. Array’in temel nitelikleri nelerdir?

3. Array’in öğeleri hangi veri türünden olabilir?

4. Array’in indeksleri hangi veri türünden olmalıdır?

5. Arra’in öğelerine nasıl erişilir?

6. Array’in dolaysız tanımı (doğrudan değişken bildirimi) nasıl yapılır?

7. Array’in dolaylı tanımı (type olarak bildirimi) nasıl yapılır?

8. Numaralanmış veri türleri, array’in öğeleri olabilir mi?

9. Numaralanmış veri türleri, array’in indeksleri olabilir mi?

10. Packed Array ne demektir?

11. Metinler array olarak nasıl temsil edilir?

12. İki boyutlu bir array nasıl tanımlanır?

13. İki boyutlu bir array’in indisleri aynı türden mi olmalıdır?

14. Çok boyutlu arrayler kullanılırken, iç içe döngüler neden çok işe yarar?

15. Bir array bütün olarak bir sayısal işlemde yer alabilir mi?

16. Bir array bütün olarak bir mantıksal ifadede yer alabilir mi?

17. Bir array bütün olarak read deyimi ile bir seferde okunabilir mi? Metinler için farklılık var mıdır?

18. Bir array bütün olarak write deyimi ile bir seferde yazılabilir mi? Metinler için farklılık var mıdır?

19. Arrayler, procedurlerde parametre olabilir mi?

20. Bir programda N öğeli bir array tanımlandığında, program bunların hepsini kullanmak zorunda mıdır?

21.