Znowu niestety wkraczamy w głębokie wody i zaczynamy dość trudną lekcję. Chodzi mianowicie o tablice. Nie chodzi tu oczywiście o tablicę, po której pisze się kredą, a grupy zmiennych. Określenie to nie jest zbyt fachowe, jednak abyście lepiej sobie mogli wyobrazić, o co chodzi, załóżmy, że są to grupy zmiennych. Jak zwykle, wszystko wyjaśni się na podstawie przykładowego programu. Załóżmy, że użytkownik ma wprowadzić do komputera 20 liczb. Po wprowadzeniu, komputer ma je wyświetlić w odwrotnej kolejności po przecinku. Nie używając jeszcze ci nie znanych tablic, program wyglądał będzie tak:

USES CRT;

VAR
a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18,a19,a20:integer;

BEGIN
clrscr;
writeln('Wprowadź kolejno 20 liczb');
read(a1);
read(a2);
read(a3);
read(a4);
read(a5);
read(a6);
read(a7);
read(a8);
read(a9);
read(a10);
read(a11);
read(a12);
read(a13);
read(a14);
read(a15);
read(a16);
read(a17);
read(a18);
read(a19);
read(a20);
clrscr;
write(a20,',');
write(a19,',');
write(a18,',');
write(a17,',');
write(a16,',');
write(a15,',');
write(a14,',');
write(a13,',');
write(a12,',');
write(a11,',');
write(a10,',');
write(a9,',');
write(a8,',');
write(a7,',');
write(a6,',');
write(a5,',');
write(a4,',');
write(a3,',');
write(a2,',');
write(a1,',');
readln;
END.

Powyższy program ilustruje sposób rozwiązania tego problemu. Sposób ten nie jest jednak zbyt wygodny, gdyż pomyślmy, co by było gdyby użytkownik miał wprowadzić 1000 liczb albo i więcej. Poza tym, zmienne wszystkie są takie same, dodatkowo użyłem podobnych nazw. Czemu zatem, nie skorzystać z tablic. Ten sam program, ale z użyciem tablic wygląda tak:

USES CRT;

VAR
a:array[1..20]of integer;

BEGIN
clrscr;
writeln('Wprowadź kolejno 20 liczb');
read(a[1]);
read(a[2]);
read(a[3]);
read(a[4]);
read(a[5]);
read(a[6]);
read(a[7]);
read(a[8]);
read(a[9]);
read(a[10]);
read(a[11]);
read(a[12]);
read(a[13]);
read(a[14]);
read(a[15]);
read(a[16]);
read(a[17]);
read(a[18]);
read(a[19]);
read(a[20]);
clrscr;
write(a[20],',');
write(a[19],',');
write(a[18],',');
write(a[17],',');
write(a[16],',');
write(a[15],',');
write(a[14],',');
write(a[13],',');
write(a[12],',');
write(a[11],',');
write(a[10],',');
write(a[9],',');
write(a[8],',');
write(a[7],',');
write(a[6],',');
write(a[5],',');
write(a[4],',');
write(a[3],',');
write(a[2],',');
write(a[1],',');
readln;
END.

Tak wyglądał program z użyciem tablic. Tablica ma nazwę "a" i składa się z 20 elementów typu INTEGER. To tak, jak gdyby była grupa 20 tych samych zmiennych, dodatkowo ponumerowanych. Spójrzcie na deklaracje. Po nazwie tablicy następuje dwukropek oraz słówko "ARRAY". Następnie w kwadratowych nawiasach podajemy ich numery: początkowy, dwie kropki oraz końcowy. Na końcu podajemy typ używając dodatkowo słówka "OF". Tak wygląda deklaracja. Tablice używa się podobnie, stosując numer w kwadratowym nawiasie. Jak widzimy, numer w nawiasie ciągle się zwiększa, a w drugiej części programu - zmniejsza. Możemy tu skorzystać z pętli, a numer zastąpić dodatkową zmienną. Spróbujmy, więc nieco uzwięźlić nasz program, aby zajmował mniej miejsca.

USES CRT;

VAR
a:array[1..20]of integer;
k:integer;

BEGIN
clrscr;
writeln('Wprowadź kolejno 20 liczb');
k:=0;
REPEAT
k:=k+1;
read(a[k]);
UNTIL k=20;
clrscr;
REPEAT
write(a[k]);
write(',');
k:=k-1;
UNTIL k=0;
readln;
END.

Z powyższego programu widać, że zamiast licznika, wprowadziłem dodatkową zmienną, nazwaną jako "k". W deklaracji jest osobno podana, gdyż nie można wymieniać po przecinku tablic ze zmiennymi (tylko zmienne). Program korzysta z pętli, w której cały czas zwiększana jest wartość licznika, a co za tym idzie - numer elementu tablicy "a". W drugiej pętli to samo, z tym, że licznik jest zmniejszany. W ten prosty sposób, program nasz działa tak jak poprzednie, a mniej zajmuje. Możemy go jeszcze bardziej zmniejszyć, aż do takiej postaci:

USES CRT;

VAR
a:array[1..20]of integer;
k:integer;

BEGIN
clrscr;
writeln('Wprowadź kolejno 20 liczb');
FOR k:=1 TO 20 DO read(a[k]);
clrscr;
FOR k:=20 DOWNTO 1 DO write(a[k],',');
readln;
END.

Jak widać udało nam się skompresować nasz program do zaledwie kilku linijek tekstu. Porównajcie to teraz z pierwszym programem z tej lekcji, a zobaczycie różnice. W powyższym kodzie, zastosowałem pętlę "FOR". Jak widać, bardzo się tu przydała. Pętla operuje licznikiem "k", czyli jednocześnie numer elementu tablicy. W ten sposób wszystko idzie po kolei i ma swoje miejsce. Zwróćmy uwagę na brak bloków "BEGIN" i "END" przy poleceniach pętli - jeżeli jest tylko jedno polecenie, to bloki są zbędne (ale to na marginesie). Nic więcej tłumaczyć chyba nie muszę.

Pamiętacie coś takiego jak zagnieżdżanie pętli? Po prostu wpisywaliśmy jedną pętlę w drugą. Tak samo można postępować z tablicami, (czyli np. grupa iluś tam elementów, z których każdy składa się z iluś tam). Takie tablice nazywamy tablicami dwuwymiarowymi. Daje to nam bardzo duże możliwości w wszelakich programach. Deklaracja takiej dwuwymiarowej tablicy wygląda przykładowo tak:

a:array[1..10] of array[1..50] of integer;

Jak łatwo się tu domyśleć, mamy tablicę 10-cio elementową, z których każdy z tych elementów składa się z 50 mniejszych elementów. Inaczej mówiąc, razem, mamy 500 elementów posegregowanych w10 grup. Ich wywołanie wykonuje się tak samo jak w zwykłych tablicach, z tym, że w kwadratowym nawiasie należy podać dwie liczby po przecinku. Pierwsza liczby to numer "pierwszego wymiaru", druga - drugiego. Powyżej, pierwszy wymiar składa się z 10 elementów, a drugi z 50. Tak oto stworzyliśmy tablicę dwuwymiarową. Możemy również tworzyć trój, cztero i więcej wymiarowe tablice. Jak widać, tablice dają nam ogromne możliwości.

---