Typy Tablicowe

Przypomnienie:
Zapewne kojarzysz co to jest zmienna, ale przypomnę jakie są jej funkcje. Zmienna podobnie
jak stała przechowuje w pamięci jakąś wartość podczas wykonywania programu. Zmienne różnych typów mogą przechowywać różne wartości np. zmienna typu char może posiadać wartość w  postaci znaku ASCII (1 bajt), a zmienna typu byte może przechowywać wartości liczbowe w zakresie od 0 do 255 itd. Zmienna różni się od stałej tym, że podczas wykonywania programu jej wartość może ulec zmianie, a wartość stałej jest przez cały okres wykonywania programu taka sama.
Deklaracje stałych i zmiennych;
const nazwastalej=wartosc;
var nazwazmiennej    :typ;

Ok. To co wyżej napisałem wystarczy wam do poznania tablic.

Wprowadzenie
Wyobraź sobie, ze piszesz program. Potrzebujesz wprowadzić 15 różnych liczb całkowitych do piętnastu różnych zmiennych. Aby to wykonać musisz zdeklarować 15 zmiennych, a następnie 15 razy użyć funkcji read(zmienna). Zajęło by sporo miejsca, a co dopiero jeśli trzeba było by wprowadzić 150 różnych liczb. Właśnie do tego celu stworzono tablice.
Tablica - jest to zbiór zmiennych (bądź stałych - o tym później) tego samego typu. Każda  taka "zmienna" w tablicy nazywana jest elementem tablicy.   
Wielu podręcznikach lub kursach dotyczących podstaw Pascal’a tablice są deklarowane w sekcji "var". My będziemy najpierw opisywać typ tablicowy (type), a następnie w sekcji „var” będziemy deklarować zmienną wcześniej opisanego typu. W ten sposób zadeklarowana tablica będzie mogła zostać przekazana do funkcji lub procedury jako parametr.

Słowem kluczowym dotyczącym tablic jest słowo "array" co z ang. oznacza tablica.
Przykładowy program zawierający deklarację tablicy:

Program definicja_tablicy;
uses Crt;
Const lw = 3;                    
Type T_tablica = array[1..lw] of byte;  {opisujemy typ tablicowy, ktorego ilosc elementow                                             przekazywane jest przez stala lw}

var  Tablica   : T_Tablica;        {deklarujemy zmienna tego typu}

begin
end.

Do tablic i jej elementów odnosimy się prawie tak samo jak do zmiennych, z tym, że po  nazwie tablicy w nawiasach kwadratowych podajemy numer elementu. np:

Tablica[1]:=6;       {Elementowi 1 z tablicy przypisz 6};
write(Tablica[3]); {Wypisz wartosc elementu 3 z tablicy}
read(Tablica[2]);  {wprowadz wartosc dla elementu 2 z tablicy}

Wykonaj poniższe ćwiczenia, pamiętaj, aby wyświetlać wartości przejrzyście
np.

writeln('Element 1: ',Tablica[numerelementu]);

-- CWICZENIE --
Zadeklaruj tablice 4 elementowa typu byte, a w programie za pomocą instrukcji przypisania  elementowi 1 przypisz dowolna wartość z zakresu od 0 do 255, pozostałym elementom wprowadź wartość z klawiatury (read/readln), a następnie wyświetl wszystkie elementy tablicy.

PAMIETAJ TYP BYTE MOZE "PAMIETAC" WARTOŚCI Z ZAKRESU OD 0 DO 255!
-- koniec ćwiczenia --

-- CWICZENIE 2 --
Zadeklaruj tablice 4 elementową typu char, elementowi 1 przypisz wartość dowolnego znaku z tablicy ASCII, a pozostałym elementom wprowadź wartość z klawiatury. Na końcu wyświetl wszystkie elementy tablicy.
-- koniec ćwiczenia --

Jeśli zrobiłeś te ćwiczenia bez problemu to możesz iść dalej, jeśli nie to pisz: w temacie  albo gg.

Jak widać ćwiczenia były banalne, mam nadzieję, że teraz umiesz zadeklarować tablice  (opisać typ i zadeklarować zmienną tego typu), wprowadzać do jej elementów wartości i  wypisywać wartości elementów.

Wymiary
Aby było fajniej tablice posiadają swoje wymiary. Wszystkie dotychczas tablice były jedno  wymiarowe: czyli Tablica posiadała "lw" wierszy. ("lw" - stała określająca ilość wierszy  (elementów) w tablicy).

Tablice dwuwymiarowe: logicznie ująć - posiadają "lw" wierszy i "lk" kolumn, (lk - stała  określająca ilość kolumn w tablicy). Tablice dwuwymiarowe można sobie wyobrazić jako tabele (otwórz sobie arkusz kalkulacyjny to obrazowo zobaczysz jak to wygląda), a ich deklaracje są prawie tak banalne jak deklaracje tablic jednowymiarowych:

Program definicja_tablicy_dwuwymiarowej;
uses Crt;
Const lw = 3;  {liczba wierszy}
      lk = 4;  {liczba kolumn }            {    
Type T_tablica = array[1..lw,1..lk] of byte; 

var  Tablica   : T_Tablica;        {deklarujemy zmienna tego typu}

begin
end.

Jak widać w przykładzie array[1..lw,1..lk] w pierwszej kolejności deklarujemy liczbę
wierszy a w drugiej (po przecinku) deklarujemy liczbę kolumn. Tablica w przykładzie
posiada 4 kolumny po 3 wiersze, czyli łącznie posiada 12 elementów.
Jak odnosimy się do elementów tablic dwuwymiarowych? Prawie tak samo jak do  jednowymiarowych:

Tablica[1,2]:=6;       {Elementowi w wierszu 1 kolumnie 2 przypisz 6}
write(Tablica[3,4]);        {Wypisz wartosc elementu w wierszu 3 kolumnie 4}
read(Tablica[2,2]);        {wprowadz wartosc dla elementu w 2 wierszu kolumnie 2}

Trochę z tymi wymiarami namieszałem, ale mam nadzieje, ze ogarniacie

-- CWICZENIE 1 --
Zadeklaruj tablice dwuwymiarowo o wymiarach 2x2 typu integer, a następnie wypełnij ja 
dowolnymi wartościami. Na końcu wypisz wszystkie wartości.
-- koniec ćwiczenia --

Jeśli ogarniasz juz deklaracje tablic jedno, dwuwymiarowych i umiesz odnosić się do ich  elementów to bardzo fajnie, lecz tak na prawdę to jeszcze dużo o nich nie wiesz .

Tablice trójwymiarowe - pewnie myślisz sobie WTF? Juz wyjaśniam! Można deklarować tablice wielowymiarowe (np. 10 wymiarowe), lecz nie znajduje to praktycznego zastosowania. Najczęściej spotyka się tablicę jednowymiarowe, dwuwymiarowe i bardzo rzadko trójwymiarowe.
Jak wyobrazić sobie tablicę trójwymiarową? :
Wyobraź sobie blok (czyli tablica), w bloku są 3 klatki, które zawierają lk pięter, a każde  piętro zawiera lw mieszkań.
Jak zadeklarować taką tablicę?

Program 3wymiary;
uses Crt;
Const lw = 3;  {liczba wierszy}
      lk = 4;  {liczba kolumn }            {    
Type T_tablica = array[1..lw,1..lk,1..3] of byte; 
var  Tablica   : T_Tablica;        {deklarujemy zmienna tego typu}
begin
end.

Ogólnie jeśli nie ogarniasz trójwymiarowych tablic to nie masz co się przejmować, ponieważ są one rzadko spotykane.

Stałe tablicowe

Wszystkie dotychczasowe tablice deklarowaliśmy jako zmienne i w programie uzupełnialiśmy ich wartości. Istnieje również możliwość zadeklarowania stałej tablicowej i
wypełnienia jej w stałej. Analogicznie jak zmienne i stałe - tablice deklarowane przez zmienną mogą zmieniać swoją wartość podczas wykonywania programu, tablice deklarowane stałą przez cały program mają stałe wartości, które nie mogą ulec zmianie. Ok przejdźmy do przykładu deklaracji takiej tablicy i wypełnienia jej.


Przykład dla tablicy jednowymiarowej:

Program stalatab1w;
uses Crt;
Const lw=4;
Type T_Tablica = array[1..lw] of byte;

Const Tablica:T_Tablica= (             {otworz tablice}    
                              5,1,3,7      {elementowi 1 przypisz 5, itd, uwaga przy 
                                                               ostatnim ementu brak zecinka}    
                        );   {zamknij tablice}

begin
   writeln(Tablica[1]);
   writeln(Tablica[2]);
   writeln(Tablica[3]);
   writeln(Tablica[4]);        
end.

Przyklad dla tablicy dwuwymiarowej:

Program stalatab2w;
uses Crt;
Const lw=3; lk=3;
Type T_Tablica = array[1..lw,1..lk] of byte;

Const Tablica:T_Tablica= (
                             (3,7,1), {pierwsza kolumna ma 3 elementy}
                                   (6,3,1), {druga kolumna ma 3 elementy}
                                         (9,2,4)  {trzecia kolumna ma 3 elementy}
                                     );     
                               
Begin
    writeln(Tablica[2,2]);
    writeln(Tablica[1,3]);
    writeln(Tablica[3,2]);
end.

Myślę, że jeśli zrozumiałeś wszystko od początku tego tematu, to nie powinieneś mieć problemu ze zrozumieniem tych dziwnych "stałych".

Ok, czyli umiemy opisywać typ tablicowy, deklarować zmienne i stałe opisanego typu, potrafimy wypełniać wartościami itd. ale co nam z tego skoro jeśli będziemy mieli wprowadzić do tablicy np. 20 różnych wartości? 22-krotne użycie funkcji read zajmie mnóstwo miejsca. I tu przychodzą nam z pomocą pętle, albo jak kto woli "pentle".
Wszystko na przykładzie:

Program tabpetl1w;
uses Crt;
Const lw=3;
Type T_Tablica = array[1..lw] of byte;

var Tablica :T_Tablica;
    w        :byte;        
begin
   for w:=1 to lw do
         readln(Tablica[w]);
end.

Już opisuje działanie tej pętli:
1. zmiennej ‘w’ podstaw 1
2. przeczytaj z klawiatury wartość dla elementu ‘w’
3. wróć, zwiększ zmienną ‘w’ o 1, jeśli zmienna w>lw to przerwij działanie pętli.

Tak wygląda wprowadzanie wartości do tablicy jednowymiarowej. Teraz czas na tablice dwuwymiarowe i to jest ciut bardziej skomplikowane. Trzeba skorzystać z tzw. "zagnieżdżenia pętli" czyli pętli w pętli
Przykład:

Program tabpetl2w;
uses Crt;
Const lw=3; lk=4;
Type T_Tablica = array[1..lw,1..lk] of byte;

var Tablica :T_Tablica;
    w,k        :byte;

begin
   for w:=1 to lw do
     for k:=1 to lk do
       readln(Tablica[w,k]);

end.

Jak działa ta pętla? PROSTO!:
1. zmiennej ‘w’ podstaw 1,
2. zmiennej ‘k’ podstaw 1,
3. przeczytaj z klawiatury wartość dla elementu na pozycji [w,k]
4. wróć, zwiększ zmienna ‘w’ o 1, jeśli zmienna w>lw to przerwij działanie pętli,
5. zwiększ zmienna ‘k’ o 1, jeśli zmienna k>lk to przerwij działanie pętli.

Myślę, że już wystarczy tych tablic. Komentujcie, pytajcie i zróbcie ćwiczenia

-- CWICZENIE 1 --
Zadeklaruj 2 tablice tego samego typu o wymiarach 3x3. Jedną z tych tablic wypełnij dowolnie wybranymi wartościami w STAŁEJ. Druga tablice wypełnij za pomocą pętli również dowolnie wybranymi wartościami. Korzystając z pętli wyświetl obie tablice. Następnie korzystając z pętli drugiej tablicy przypisz wartości z tablicy wypełnionej w stałej, wyczyść ekran i wyświetl jeszcze raz obie tablice. Jeśli są takie same tzn, ze dobrze wykonałeś to zad.


WSKAZOWKI:
korzystaj z ClrScr aby zachować przejrzystość;
podstawiaj wartości wg wzoru: tablica[element]:=tablica2[element];
najlepiej wyświetlaj to: writeln(Tablica1[element],' - ',Tablica2[element]);

----------

Z góry mówię, że nie stosowałem tutaj „fachowego” języka, więc jak by się uprzeć to znajdzie się kilka „technicznych” błędów. Ten temat miał na celu na „chłopski” rozum wytłumaczyć tablice, ale wydaję mi się, że trochę za mocno namieszałem.

Krytyka mile widziana, i dajcie znać czy ogarniacie coś z tego
Kostek