Dr inż. Robert Wójcik
E-mail: wojcik@ict.pwr.wroc.pl
Języki i metody programowania
7. Tablice
7.1. Deklarowanie i definiowanie tablic
7.2. Nadawanie tablicom wartości początkowych 7.3. Wykonywanie operacji na tablicach
7.4. Przekazywanie tablic do procedur i funkcji 7.5. Operacje na tablicach wielowymiarowych 7.6. Tablice znakowe a łańcuchy
7. Tablice
Tablica służy do zapamiętywania wielu elementów tego samego typu.
Indeksy tablicy muszą być typu porządkowego.
7.1. Deklarowanie i definiowanie tablic Deklaracja typu tablic:
Type
Ttab = array[1..5] of Integer;
Ttab1 = array[1..5,1..20] of Real;
Definicje zmiennych tablicowych:
Var A: Ttab; { tablica 5-ciu liczb całkowitych } B: Ttab1; { tablica 2-wymiarowa 5x20 } C: array[1..2, 1..3, 1..7] of Byte
np. A[1], A[2], A[3], A[4], A[5] - elementy tablicy A
(elementy są umieszczane w pamięci od A[1] do A[5]).
W praktyce wygodnie jest, gdy wymiar (wymiary) tablicy określa stała.
Const
m=3; { liczba wierszy tablicy } n=7; { liczba kolumn tablicy }
Type Ttab2 = array[1..m,1..n] of Longint;
Wielkość tworzonej tablicy nie może przekroczyć 64kB.
Tablica dwuwymiarowa jest składowana w pamięci wierszami.
np. Type
Ttab = array[1..33000] of Word; { rozmiar 66000B - za dużo }
Kompilator nie pozwoli utworzyć typu, którego zmienna przekroczyłaby 64kB.
7.2. Nadawanie tablicom wartości początkowych
Elementy tablic, po deklaracji zmiennej tablicowej, mają przypadkowe wartości.
Można zainicjować tablicę deklarując ją jako zmienną z wartością począ- tkową w oparciu o słowo kluczowe const. Należy wówczas inicjować wszystkie elementy tablicy.
Można inicjować tablice znaków stałymi łańcuchowymi o rozmiarze mniejszym niż wymiar tablicy. Elementy tablic globalnych, które nie zostały ustalone na etapie definicji są inicjowane zerami.
Const N = 3;
W= 2;
Tab: array[1..N] of Byte = (1,3,5); { inicjowane wszystkie elementy } Tab1: array[1..W] of array[1..N] of Real = ((2,-1,3),(1,3,7));
Litery: array[’a’..’c’] of Char = ’a’; { pozostałe elementy zerowe } Litery1: array[1..3] of Char = (’a’,’b’,’c’);
Wartości ustalone na etapie definicji tablic można modyfikować.
Tab[1]:= 4; Tab1[2,2]:= 19; Litery[’a’]:= ’x’; Litery1[3]:= ’y’;
Można zadeklarować zmienne tablicowe, a następnie zainicjować je w programie, np.
Var A: Ttab;
B: Ttab1;
i,j: Word;
begin
for i:=1 to 5 do A[i]:= i; { tablica liczb całkowitych } for i:=1 to 5 do { tablica liczb rzeczywistych } for j:=1 to 20 do B[i,j]:= 0;
{ inicjacja losowymi wartościami }
Randomize; {inicjacja generatora liczb losowych}
for i:=1 to 5 do A[i]:= random(200); { liczby całkowite [0,200) }
for i:=1 to 5 do { liczby rzeczywiste należące do [0,1) } for j:=1 to 20 do B[i,j]:= random;
for i:=1 to 5 do { liczby rzeczywiste należące do [-2.5, -1.3) } for j:=1 to 20 do B[i,j]:= 1.2random – 2.5;
for i:=1 to 5 do { rzeczywiste należące do [-5,5) } for j:=1 to 20 do B[i,j]:= -5 + 10random;
end.
W ogólnym przypadku wzór na inicjację tablicy tab losowymi liczbami rzeczywistymi należącymi do przedziału [a, b], gdzie a < b, ma następującą postać: tab[i]:= a + (b-a)random.
Wczytywanie elementów tablicy z klawiatury Var i,n: Word;
begin n:=5;
for i:=1 to n do begin
write(’Element nr ’, i,’ = ’); readln(A[i]);
end;
end.
Wyprowadzanie elementów tablicy na ekran Var i,n: Word;
begin n:=5;
for i:=1 to n do begin
write(’Element nr ’, i,’ = ’); writeln(A[i]);
end;
end.
7.3. Wykonywanie operacji na tablicach
Zamienianie elementów
Usuwanie elementów z określonej pozycji
Dopisywanie elementów na określonej pozycji
Przepisywanie elementów z jednej tablicy do drugiej, np.
Var X, Y: array[1..10] of real;
i: Word;
begin
for i:=1 to 10 do X[i]:= i;
for i:= 1 to 10 do Y[i]:= X[i] + 2;
end.
Przeszukiwanie tablic w celu odnalezienia elementów o tych samych cechach, np.
Var X, Y: array[1..10] of real;
i: Word;
begin
for i:=1 to 10 do X[i]:= i;
for i:= 1 to 10 do
if (-4< X[i]) and (X[i] < 4) then Y[i]:= X[i];
end.
7.4. Tablice jako parametry procedur i funkcji Tablice można przekazywać do procedur i funkcji:
przez wartość,
przez adres (zmienną).
Małe tablice można przekazywać do procedur przez wartość.
Type Mtab = array[1..100] of byte;
Var Mala: Mtab;
procedure zmien_mala(x: Mtab); { przekazanie przez wartość } begin
x[1]:= 2;
end;
Duże tablice lub tablice, które mają być modyfikowane wewnątrz procedur przekazujemy przez adres (zmienną).
Type Dtab = array[1..10000] of byte;
Var Duza: Dtab;
procedure zmien_duza(Var y: Dtab); { przekazanie przez adres } begin
y[1]:= 2;
end;
Funkcja nie może zwracać wartości typu tablicowego Operacje na całych tablicach
Zmienne tablicowe tego samego typu można podstawiać Type
Ttab1 = array[1..10] of Integer;
Ttab2 = array[1..10] of Integer;
Var
A1, A2: Ttab1;
A3: Ttab2;
i: Word;
{ A1 i A3 są z punktu widzenia kompilatora różnych typów }
Procedure Podstaw(Var t1, t2: Ttab1);
begin
t2:= t1;
end;
Begin
for i:=1 to 9 do A1[i]:= i; { 1 2 3 4 5 6 7 8 9 } for i:=1 to 9 do A2[i]:= 0;
Podstaw(A1,A2); { tablice przepisane } writeln(' A1 - A2');
for i:=1 to 9 do writeln(A1[i]:3, ' --- ', A2[i]);
(* Podstaw(A1,A3); { zly typ } *) readln;
End.
Na ogół tablice przekazuje się do procedur i funkcji przez zmienną. Dodatko- wo wraz z adresem tablicy przekazuje się do podprogramu parametr określający liczbę elementów tablicy (nie może on przekroczyć rozmiaru tablicy podanego w jej deklaracji). Nagłówek procedury umożliwiającej wydrukowanie k elementów tablicy typu ttab ma następującą postać:
Procedure Pisz(Var tab: ttab; k: integer) Var i: integer;
Begin
for i:=1 to k do writeln( tab[i] );
End;
Przykład. 7.1. Operacje na jednowymiarowej tablicy liczb. Inicjowanie tablicy losowymi danymi, wyprowadzanie elementów tablicy, poszukiwa- nie minimum i maksimum w tablicy, sortowanie tablicy.
Zdefiniować tablicę liczb całkowitych typu integer o rozmiarze N, gdzie N - stała. Opracować funkcje:
a) inicjującą tablicę losowymi liczbami należącymi do przedziału [-100, 100);
b) wyprowadzająca zawartość tablicy na ekran - wierszami po 10 elementów;
c) znajdującą minimalny i maksymalny element tablicy;
d) sortującą elementy tablicy rosnąco w oparciu o wybrany algorytm.
uses crt;
const n=22; { rozmiar tablicy } type ttab = array[1..n] of integer; { deklaracja typu } { definicje funkcji }
procedure inicjuj(var t: ttab; k: integer);
var i: integer;
begin
for i:=1 to k do t[i]:=-100 + random(200);
writeln('Inicjacja tablicy');
end;
procedure wyprowadz(var t: ttab; k: integer);
var i: integer;
begin
for i:=1 to k do
begin if i mod 10 = 0 then writeln(t[i]:6) else write(t[i]:6); end;
writeln; readln;
end;
procedure znajdz_min_max(var t: ttab; k: integer; var mn, mx: integer);
var i: integer;
begin
mn:=t[1]; mx:=t[1];
for i:=1 to k do begin if t[i] < mn then mn:=t[i] else if t[i] > mx then mx:=t[i];
end;
end;
procedure sortuj(var t: ttab; k:integer);
var temp, i, j: integer;
begin writeln;
writeln('Sortowanie tablicy - prosta zamiana (bĄbelkowe) ');
for i:=1 to k do for j:=1 to k-i do if (t[j]>t[j+1]) then
begin temp:=t[j]; t[j]:=t[j+1]; t[j+1]:=temp; end;
writeln; writeln('Tablica posortowana');
end;
Var tab: ttab;
min, max: integer;
Begin { program glowny } clrscr;
randomize; { start generatora liczb losowych } inicjuj(tab, N);
wyprowadz(tab, N);
znajdz_min_max(tab, N, min,max);
writeln('Element minimalny = ', min);
writeln('Element maksymalny = ', max);
sortuj(tab, N);
wyprowadz(tab, N);
End.
Przykładowe wyniki:
Inicjacja tablicy
33 54 27 96 -38 -84 -50 29 -38 -34 -75 48 -59 79 -98 94 79 62 53 68
70 89
71
Element minimalny = -98 Element maksymalny = 96
Sortowanie tablicy - prosta zamiana (bąbelkowe) Tablica posortowana
-98 -84 -75 -59 -50 -38 -38 -34 27 29 33 48 53 54 62 68 70 79 79 89
94 96
Inicjowanie tablic znakowych
Tablice znaków można inicjować losowymi danymi w oparciu o funkcję random podobnie jak tablice liczb. Do konwersji danej liczbowej na znak można wykorzystać funkcję chr, natomiast do konwersji odwrotnej funkcję ord.
Możliwe jest również indeksowanie tablic zmienną typu char. Sposób inicjacji tablic znakowych ilustruje następujący przykład.
Przykład. 7.2. Zainicjować tablicę dane: array['A'..'Z'] of Char losowymi znakami z przedziału od 'A' do 'Z'. Wpisać do tablicy licz: array['A'..'Z'] of Byte liczbę wystąpień każdego znaku w tablicy dane.
uses crt;
Var
dane: array['A'..'Z'] of Char;
licz: array['A'..'Z'] of Byte;
i, j: Byte;
k, n: Char;
Begin clrscr;
randomize;
writeln('Inicjacja tablicy'); writeln;
for k:='A' to 'Z' do
begin
j:= ord('Z')-ord('A')+1; { ord - zamiana znaku na kod ASCII } i:= ord('A') + random(j);
dane[k]:=chr(i); { chr - zamiana kodu ASCII na znak } end;
for k:='A' to 'Z' do write(dane[k]); { wypisz dane } for k:='A' to 'Z' do licz[k]:=0; { zeruj liczniki }
for k:='A' to 'Z' do { zliczanie liczby wystapien } for n:='A' to 'Z' do
if dane[n]=k then inc(licz[k]);
writeln; writeln; writeln('Liczby wystapien znakow: ');
for k:='A' to 'Z' do write(k:2, ' - ', licz[k]:3);
readln;
End.
Przykładowe wyniki:
Inicjacja tablicy
DZNMJEPHCKKCWHJDASMNRXHSKT Liczby wystapien znakow:
A - 1 B - 0 C - 2 D - 2 E - 1 F - 0 G - 0 H - 3 I - 0 J - 2 K - 3 L - 0 M - 2 N - 2 O - 0 P - 1 Q - 0 R - 1 S - 2 T - 1 U - 0 V - 0 W - 1 X - 1 Y - 0 Z - 1
7.5. Operacje na tablicach wielowymiarowych
Tablica dwuwymiarowa może być rozpatrywana jako tablica kilku tablic jednowymiarowych, stanowiących wiersze tablicy dwuwymiarowej. Tablica dwuwymiarowa tab[1..W, 1..N] jest pamiętana w pamięci wierszami, tj. kolejno są składowane elementy tab[1,1], tab[1,2], ..., tab[1,..,N], tab[2,1], tab[2,2], ..., tab[2,N], itd.
W ogólnym przypadku elementy tablicy n - wymiarowej są składowane w pamięci w taki sposób, że najpierw zmieniają się prawe skrajne indeksy tablicy, tj. [1,1,...,1,1], [1,1,...,1,2], ... [1,1,...,1,N], [1,1,...,2,1], ... , itd.
Przykład. 7.3. Operacje na dwuwymiarowej tablicy liczb. Inicjowanie tablicy losowymi danymi, wyprowadzanie elementów tablicy, poszukiwa- nie minimum i maksimum w tablicy, sortowanie każdego wiersza tablicy.
Zdefiniować dwuwymiarową tablicę liczb całkowitych typu integer o W wierszach i N kolumnach, gdzie W, N są stałymi w programie:
Opracować funkcje:
a) inicjującą tablicę losowymi liczbami należącymi do przedziału [-100, 100);
b) wyprowadzająca zawartość tablicy na ekran - wierszami;
c) znajdującą minimalny i maksymalny element tablicy;
d) sortującą elementy każdego wiersza tablicy rosnąco.
W przypadku tablic dwuwymiarowych należy używać dwóch zmiennych sterujących, np. i oraz j, które są indeksami tablicy tab[i,j]. Procedury:
inicjująca, wyprowadzająca dane na ekran oraz znajdująca minimum i maksimum w tablicy są analogiczne do procedur opracowanych dla tablicy jednowymiarowej o N elementach. Parametrami procedur są wymiary podtablicy reprezentowane przez wartości n_w (liczba wierszy) oraz n_k (liczba kolumn).
Sortowanie każdego wiersza można zrealizować na dwa sposoby.
Pierwszy sposób polega na opracowaniu nowej procedury sortowania, która realizuje algorytm sortowania bąbelkowego dla każdego wiersza tablicy dwuwymiarowej. Parametrem tej procedury jest tablica dwuwymiarowa. Drugi sposób polega na wywołaniu w pętli procedury sortowania opracowanej dla tablicy jednowymiarowej i przekazanie do niej adresu każdego wiersza tablicy dwuwymiarowej. Parametrem tej procedury jest tablica jednowymiarowa. Kod źródłowy procedur przedstawiono w kolejnym programie.
const
W=7; { liczba wierszy tablicy } N=5; { liczba kolumn tablicy } type
ttab = array[1..N] of integer; { typ - tablica N - kolumnowa}
tdw = array[1..W, 1..N] of integer; { typ - tablica dwuwymiarowa; } { W – wierszy; N – kolumn } { inicjowanie }
procedure inicjuj1(var t: tdw; n_w, n_k: integer);
var i,j: integer;
begin
for i:=1 to n_w do
for j:=1 to n_k do t[i,j]:=-100 + random(200);
writeln('Inicjacja tablicy dwuwymiarowej');
end;
{ wyprowadzanie }
procedure wyprowadz1(var t: tdw; n_w, n_k: integer);
var i,j: integer;
begin
for i:=1 to n_w do { wydruk po wierszach }
begin for j:=1 to n_k do write(t[i,j]:6); writeln; end;
end;
{ szukanie min i max }
procedure znajdz_min_max1(var t: tdw; n_w,n_k: integer;
var mn, mx: integer);
var i,j: integer;
begin
mn:=t[1,1]; mx:=t[1,1];
for i:=1 to n_w do for j:=1 to n_k do
begin if t[i,j] < mn then mn:=t[i,j] else if t[i,j] > mx then mx:=t[i,j]; end;
end;
{ sortowanie wierszy }
procedure sortuj_wier(var t: tdw; n_w, n_k:integer);
var temp, h, i, j: integer;
begin
writeln; writeln('Sortowanie wierszy podtablicy ');
for h:=1 to n_w do begin
for i:=1 to n_k do for j:=1 to n_k-i do if (t[h,j]>t[h,j+1]) then
begin temp:=t[h,j]; t[h,j]:=t[h,j+1]; t[h,j+1]:=temp; end;
end;
writeln; writeln('Tablica posortowana');
end;
procedure sortuj(var t: ttab; k:integer);
var temp, i, j: integer;
begin writeln;
writeln('Sortowanie tablicy - prosta zamiana (bĄbelkowe) ');
for i:=1 to k do for j:=1 to k-i do if (t[j]>t[j+1]) then begin
temp:=t[j]; t[j]:=t[j+1]; t[j+1]:=temp;
end;
writeln; writeln('Tablica jednowymiarowa - posortowana');
end;
Var tab: ttab; { tablica jednowymiarowa – wymiary 1 x N } i, min, max: integer;
dw: tdw; { tablica dwuwymiarowa – wymiary W x N }
Begin { program glowny } clrscr;
randomize; { start generatora liczb losowych } inicjuj1(dw, W, N); { inicjacja tablicy dw }
wyprowadz1(dw, W, N); { dane na ekran } readln;
znajdz_min_max1(dw, W, N, min, max); { szukanie min i max } writeln('Element minimalny = ', min);
writeln('Element maksymalny = ', max);
readln;
sortuj_wier(dw, W, N); { sortowanie wierszy – tablica dwuwymiarowa dw } wyprowadz1(dw, W, N);
readln;
inicjuj1(dw, W, N); { inicjacja } wyprowadz1(dw, W, N);
readln;
for i:=1 to W do
sortuj(ttab(dw[i]), N); { sortowanie wierszy dw jako tablic typu ttab (1 x N) } wyprowadz1(dw, W, N);
readln;
End.
Przykładowe wyniki:
Inicjacja tablicy dwuwymiarowej -21 68 83 -56 49
40 54 93 32 -60 87 28 13 99 -41 -60 61 -48 -7 -1 -88 10 -98 44 -97 -59 83 -56 -39 -94 78 3 -95 21 -14 Element minimalny = -98 Element maksymalny = 99 Sortowanie wierszy podtablicy Tablica posortowana
-56 -21 49 68 83 -60 32 40 54 93 -41 13 28 87 99
-60 -48 -7 -1 61 -98 -97 -88 10 44 -94 -59 -56 -39 83 -95 -14 3 21 78
Inicjacja tablicy dwuwymiarowej 91 -73 -1 35 7
37 -72 -2 26 43 -43 -40 44 -85 -73 25 -16 43 39 -31 -36 -73 80 -73 -6 94 2 15 8 90 82 83 90 53 -42
{ sortowanie każdego wiersza za pomocą procedury sortuj } -73 -1 7 35 91
-72 -2 26 37 43 -85 -73 -43 -40 44 -31 -16 25 39 43 -73 -73 -36 -6 80 2 8 15 90 94 -42 53 82 83 90
Dostęp do tablic wielowymiarowych wymaga użycia tylu zmiennych sterujących ile wynosi liczba wymiarów tablicy. Kolejny przykład ilustruje sposób zliczania liczby powtórzeń pewnej danej w tablicy liczb rzeczywistych o trzech wymiarach.
Przykład. 7.4. Wyznaczyć liczbę powtórzeń danej x w tablicy liczb rzeczywistych o trzech wymiarach zadanych za pomocą stałych.
Const
w1 = 2; { wymiary tablicy } w2 = 4;
w3 = 6;
Type ttab = array[1..w1, 1..w2, 1..w3] of real; { typ tablicowy } Procedure Policz(var t: ttab; z1, z2, z3: integer; x: real; var licz: word);
Var i,j,k: integer;
Begin
for i:=1 to z1 do
for j:=1 to z2 do for k:=1 to z3 do
if t[i, j, k] = x then inc(licz);
End;
Var tablica: ttab; { tablica typu ttab } x: real; { poszukiwana liczba }
ile: word; { liczba wystąpień } Begin
{ inicjacja tablicy ... } x:=1.0; ile:=0;
Policz(tablica, w1, w2, w3, x, ile);
Writeln(’Liczba wystapien danej x = ’, x, ’ wynosi: ’, ile);
readln;
End.
W przypadku tablic kwadratowych array[1..N, 1..N] o wymiarach N x N można rozważać przekątne tablicy. Jedna z przekątnych zawiera elementy tablicy t[i, j] o tych samych wartościach współrzędnych [i, i], natomiast druga przekątna zawiera elementy o współrzędnych [i, N+1-i].
Przykład. 7.5. Wylosować dane z przedziału [2,10) do tablicy kwadratowej liczb całkowitych typu integer. Wyprowadzić zawartość tablicy na ekran.
Opracować procedurę inicjującą elementy na obu przekątnych wartością równą 1.
const N=5;
type
tkw = array[1..N, 1..N] of integer; { typ – tablica kwadratowa N x N } procedure UstawPrzek(var t: tkw; k: integer);
var i,j: integer;
begin
for i:=1 to k do for j:=1 to k do
if (j=i) or (j=k+1-i) then t[i,j]:=1;
end;
t[i, N+1-i]
t[i, i]
Var i, j: integer;
tt: tkw; { tablica kwadratowa typu tkw } Begin
clrscr;
randomize; { start generatora liczb losowych }
writeln('Inicjacja tablicy kwadratowej'); writeln;
for i:=1 to N do begin
for j:=1 to N do
begin tt[i,j]:=random(8)+2; write(tt[i,j]:3); end;
writeln;
end;
UstawPrzek(tt, N); writeln;
writeln; writeln('Modyfikacja'); writeln;
for i:=1 to N do begin
for j:=1 to N do write(tt[i,j]:3);
writeln;
end;
readln;
End.
Przykładowe wyniki:
Inicjacja tablicy kwadratowej 6 2 2 5 5
8 5 6 6 7 9 4 5 7 4 9 3 4 6 6 2 5 3 7 9 Modyfikacja 1 2 2 5 1 8 1 6 1 7 9 4 1 7 4 9 1 4 1 6 1 5 3 7 1
7.6. Tablice znakowe a łańcuchy
W języku Pascal elementy tablic można wczytywać i wyprowadzać na ekran pojedynczo. Na przykład ciąg znaków można wprowadzić do tablicy typu char za pomocą instrukcji readln i wyprowadzić na ekran za pomocą instrukcji write.
const N=5;
type tznak = array[1..N] of char;
Var i: integer;
tab: tznak;
begin
for i:=1 to N do { wczytywanie do tablicy } begin
write(’Element nr ’, i,’ = ’); readln(tab[i]);
end;
writeln(’Wydruk elementow ’);
for i:=1 to N do write(tab[i]);
end.
W celu ułatwienia dostępu do danych tekstowych wprowadzono w systemie Borland Pascal 7.0 typ łańcuchowy – string. Zmienne tego typu są tablicami znakowymi o dynamicznie zmieniającej się długości w zakresie od 1 do 255.
Na pozycji zerowej tablicy pamiętana jest aktualna długość łańcucha.
Deklarowanie typów i zmiennych łańcuchowych Typ łańcuchowy służy do zapamiętywania ciągu znaków.
type
lancuch20 = string[20];
Jest to deklaracja typu łańcuchowego 20 znakowego. Definicja zmiennej tego typu ma postać:
var zm: lancuch20;
Jest to zmienna służąca do przechowywania tekstu złożonego maksymalnie z 20 znaków.
Przykłady innych deklaracji:
type
lan = string;
lan255 = string[255];
var
zm: lan;
a: string;
b: lan255;
c: string[5];
Jeśli w deklaracji typu lub zmiennej pominie się długość łańcucha to domyślnie przyjmowana jest długość maksymalna równa 255 znaków.
Format zmiennej łańcuchowej w pamięci
Można definiować stałe łańcuchowe, zmienne łańcuchowe z wartością początkową lub inicjować zmienne łańcuchowe za pomocą instrukcji przypisania.
Stałe łańcuchowe const
naz = ’Kowalski’;
imie = ’Tomasz’;
Zmienne inicjowane
const nazwa : string = ’To jest tekst’;
Instrukcja przypisania
var lan: string;
lan:= ’Kowalski’;
Dla zmiennej łańcuchowej w pamięci jest rezerwowany 1 bajt przeznaczony na zapamiętanie aktualnej długości łańcucha oraz bajty przeznaczone na zapamiętanie znaków łańcucha.
lan | #8 | ’K’ | ’o’ | ’w’ | ’a’ | ’l’ | ’s’ | ’k’ | ’i’ | ... | ... | ...
0 1 2 3 4 5 6 7 8
Pozycja lan[0] zawiera znak, którego numer w kodzie ASCII odpowiada liczbie znaków łańcucha. Elementy lan[1]=’K’, lan[2]=’o’, ... ,lan[8]=’i’ zawierają kolejne znaki łańcucha. Pozycje łańcucha o numerach większych niż długość łańcucha są zajmowane przez dowolne (przypadkowe) znaki. W rozpatrywa- nym przypadku są to pozycje lan[9], lan[10], itd.
Jeśli zmiennej łańcuchowej zostanie przypisany tekst dłuższy niż deklaro- wana, maksymalna długość łańcucha, to nastąpi jego obcięcie. W przypadku podstawiania danych na zmienną łańcuchową długość łańcucha jest automatycznie ustawiana przez kompilator.
var dana: string[5];
dana:= ’Kowalski’;
Zmienna dana będzie zawierać łańcuch ’Kowal’ złożony z 5 znaków.
Z przedstawionych rozważań wynika, że kompilator rezerwuje dla zmiennej łańcuchowej maksymalną zadeklarowaną liczbę bajtów. W szczególności, var
tab: array[1..10] of string;
Tablica tab zajmuje 10256 = 2560 bajtów.
Odwoływanie się do elementów łańcucha
Do pojedynczych znaków łańcucha można odwoływać się tak, jak do elementów tablicy znaków. Należy przy tym pamiętać, aby indeksy tablicy nie przekroczyły aktualnej długości łańcucha. Długość łańcucha s można uzyskać za pomocą funkcji standardowej length(s) lub jako ord(s[0]).
Var
i: integer;
s: string;
begin
s:= ’Program’;
for i:=1 to length(s) do write(s[i], ’ – ’); { P – r – o – g – r – a – m – } writeln;
for i:=1 to ord(s[0]) do write(s[i], ’ – ’); { P – r – o – g – r – a – m – } end.
Skracanie długości łańcucha
Długość łańcucha s można zmienić podstawiając za s[0] nową wartość.
Var
s: string;
begin
s:= ’Pascal’;
writeln(s, ’ ’, length(s), ’ ’, ord(s[0]) ); { Pascal 6 6 } s[0]:= chr(3); { s[0]:= #3 }
writeln(s, ’ ’, length(s), ’ ’, ord(s[0]) ); { Pas 3 3 } end.
Wczytywanie i wyprowadzanie łańcuchów
Zmienną typu łańcuchowego można wczytać bezpośrednio z klawiatury za pomocą instrukcji readln oraz wyprowadzić na ekran za pomocą instrukcji writeln.
Var s: string;
begin
write(’Podaj tekst : ’); readln(s);
writeln(’Wprowadzono tekst: ’, s); readln;
end.
Łączenie dwóch łańcuchów
Dwie zmienne łańcuchowe s1, s2 można połączyć w jedną zmienną za pomocą operatora dodawania lub za pomocą funkcji standardowej Concat, która pozwala połączyć kilka łańcuchów.
Var
s, s1, s2: string;
begin
s1:= ’Turbo’;
s2:= ’Pascal’;
s:= s1 + s2; { s = ’Turbo Pascal’ } s:= Concat(s1, s2, ’7.0’); { s = ’Turbo Pascal 7.0’ } end.
Porównywanie łańcuchów
Całe łańcuchy można porównywać za pomocą operatorów przyrównania i relacji: =, <, >, <=, >=, <>.
Dwa łańcuchy są równe jeśli mają taką samą długość i zawierają identyczne znaki.
Podczas porównywania łańcuchów badane są kody ASCII ich kolejnych znaków.
Jeśli na pewnej pozycji jeden z łańcuchów ma znak o większym numerze porządkowym, to jest on większy.
Jeśli na pewnej pozycji jeden z łańcuchów ma znak o mniejszym numerze porządkowym, to jest on mniejszy.
Porównywanie łańcuchów kończy się po dojściu do końca krótszego łańcucha.
Podłańcuch dłuższego łańcucha jest zawsze mniejszy.
Var
s, s1, s2: string;
b: boolean;
begin
s1:= ’Turbo’;
s2:= ’Pascal’;
b:= (s1 = s2); { b = false } b:= (s1 < s2); { b = false } b:= (s2 < s1); { b = true } b:= (s1 <> s2); { b = true } end.
Standardowe funkcje i procedury do obsługi łańcuchów
function concat(s1, s2 [, s3, ..., sn] : string): string;
Funkcja łączy kilka łańcuchów w jeden, np. s:= concat(’x’, ’y’); s:= ’xy’;
function copy(s: string; poz: integer; nb: integer): string;
Funkcja zwraca podłańcuch ws złożony z nb znaków i zaczynający się od pozycji poz łańcucha s, np. ws:= copy(’123456789’, 3, 4); ws:=’3456’;
function pos(s1,s2: string): byte;
Funkcja sprawdza, czy w łańcuchu s2 znajduje się podłańcuch s1 i zwraca numer jego pozycji początkowej. Jeśli w s2 nie występuje podłańcuch s1, to zwracane jest 0, np. i:= pos(’34’, ’12345678’); i:=3;
function length(s: string): integer;
Funkcja zwraca aktualną długość łańcucha s.
procedure delete(var s: string; poz: integer; nb: integer);
Procedura wycina z łańcucha s liczbę znaków określoną przez nb począwszy od pozycji poz łańcucha s, np. s:=’12345678’; delete(s, 3, 4); s:=’1278’.
procedure insert(s1: string; var s2: string; poz: integer);
Procedura wstawia do łańcucha s2 łańcuch s1 począwszy od pozycji poz, np.
s:= ’12345’; insert(’444’, s, 2); s:= ’14442345’.
Procedure str(x [:dlugosc [:miejsca_dziesiętne] ]; var s: string);
Procedura przekształca daną x dowolnego typu liczbowego na łańcuch, np.
a:= 12.5; str(a:7:3, s); s:= ’ 12.500’.
Procedure val(s: string; var x; var kod: integer);
Procedura przekształca łańcuch tekstowy s na liczbę x. Jeśli operacja konwersji była poprawna, to zwracany jest kod = 0, np.
x: real; i: integer; s:=’22.4’; val(s, x, i); x:= 22.4.
