Tanulság a sorozatból: " Programozási nyelv Pascal»

Ha egy tömb deklarálva van, dolgozhat vele. Például értékek hozzárendelése tömbelemekhez, és általában hétköznapi változóként kezeljük őket. Egy adott elem eléréséhez meg kell adni a tömbazonosítót (név) és az elemindexet szögletes zárójelben.

Például a Mas, A jelöléssel elérhetjük a MAS tömb második elemét és az A tömb tizedik elemét.. Kétdimenziós tömbbel végzett munka esetén két indexet jelez, egy n-dimenziós tömbnél az n. indexek.

Például a Matr bejegyzés lehetővé teszi az M tömb negyedik oszlopának negyedik sorában található elem értékének feldolgozását.

Az indexelt tömbelemeket indexelt változóknak nevezzük. Lehetetlen túllépni a tömb határain. Vagyis ha öt elem van a Mas tömbben, akkor a hatodik vagy nyolcadik elem elérése hibát eredményez.

Tekintsük az egydimenziós tömbökkel végzett munka során felmerülő tipikus műveleteket.

Egydimenziós tömb kitöltése értékekkel

Tömb kitöltése és kiadása csak elemenként végezhető el, azaz először az első elemhez adhatunk értéket, majd a másodikhoz, és így tovább, ugyanez a képernyőn való megjelenítésnél - megjelenítjük az első, második, harmadik, ill. így tovább az utolsóig.

A Pascal nem rendelkezik a tömbelemek egyszerre történő be- és kimeneti lehetőségével, ezért a bevitel és az értékek elemenként kerülnek végrehajtásra. Az értékek hozzárendelhetők egy tömbelemhez a hozzárendelési operátor segítségével, vagy beírhatók a billentyűzetről Olvassa el a nyilatkozatokat vagy readln. Nagyon kényelmes egy for ciklusban egy tömb összes elemén át ismételni.

Az egydimenziós tömbök kitöltésének módjai:

1. Érték bevitele a billentyűzetről.
2. Értékek beállítása egy hozzárendelési utasításban véletlenszám-generátor segítségével. Ez a módszer kényelmesebb, ha sok elem van a tömbben (hosszú ideig tart, amíg beírják az értékeket a billentyűzetről).
3. Értékek beállítása képletekkel.
4. Tömbelemek bevitele fájlból

1. A tömbelemek értékeinek bevitele a billentyűzetről. A Readln utasítás használatának köszönhetően minden érték új sorba kerül.

2. Tömb kitöltése intervallumból véletlenszerűen generált számok. Csatlakoztatjuk a véletlenszám-generátort - a véletlenszerű függvényt.

3. töltő sor képlet szerint. A tömb minden eleméhez hozzá van rendelve a képlet által kiszámított érték. Ha a tömb minden eleme egyenlő a sorozatszám (index) értékének háromszorosával, akkor az eljárás így fog kinézni:

4. Számok olvasása fájlból. Előzetesen létre kell hoznia egy szöveges fájlt, amelybe több sort kell írni, amelyek mindegyike 30 számot tartalmaz.

A tömbelemek értékeinek megjelenítése a képernyőn

Következtetés elemértékek sor a képernyőn történik, mint a bemenet, elemről elemre ciklusban. A kimenethez a Write vagy Writeln utasításokat fogjuk használni. Bemeneti paraméterként nem csak egy tömböt adunk át az eljárásnak, hanem a megjelenítendő elemek számát is, az elsőtől kezdve (erre akkor lesz szükségünk, amikor elemeket eltávolítunk és hozzáadunk a tömbhöz).

1. példa Töltse ki a tömböt a billentyűzetről, és jelenítse meg a képernyőn.

Megoldás.

A program két eljárást fog használni: az Init1 eljárást (a tömb kitöltése a billentyűzetről) és a Print eljárást (a tömb megjelenítése a képernyőn).

2. példa Tömb kitöltése innen szöveges fájlés megjeleníti a képernyőn. Egy szövegfájlban több sor van, minden sor 30 számot tartalmaz.

Megtanulta az egydimenziós tömb kitöltését és a képernyőn való megjelenítését.

A következő leckében az egydimenziós tömbök feldolgozásának algoritmusaival folytatjuk az ismerkedést.

Szakaszok: Számítástechnika

Célok:

1. Megismertetni a tanulókkal a tömb kitöltésének és feldolgozásának lehetőségét.
2. Hozzon létre egy grafikus felületet a projekt számára, hogy kitöltse egy tömböt, és kiszámítsa az adott tömb elemeinek összegét.
3. Fejlessze a kognitív érdeklődést a téma iránt
4. A tanuláshoz való felelősségteljes hozzáállás kialakítása

AZ ÓRÁK ALATT

1. A lecke frissítése

Idő szervezése

Frontális felmérés az előző témában „A tömb fogalma. Egydimenziós tömb”

2. A készségek és képességek kialakítása

Új anyag magyarázata

Tömb deklaráció

Egy tömb deklarálása ugyanúgy történik, mint a változó deklaráció, csak az indexváltozás tartományát kell megadni. Például egy 10 elemet tartalmazó egydimenziós egész tömb a következőképpen van deklarálva:

A: egész számok tömbje;

Alapvető feladatok a tömbökkel végzett munka során

1. Tömb kialakítása (kitöltése).

1.1. a képletek szerint Az i:=1-től 10-ig tegye a[i]:= i*i;

1.2. véletlenszerűen generál i:=1-től 10-ig tegye a[i]:= random(20):

A RANDOM(MAX) beépített függvény egy véletlenszerű egész számot ad vissza, amely egyenletesen eloszlik a 0 és MAX - 1 tartományban (a MAX az inverziós paraméter).

1.3. Enter a billentyűzetről i:=1-től 10-ig olvass(a[i]);

2. Tömb rendezése (növekvő, csökkenő);

3. Elemek keresése egy tömbben;

4. Elemek kiválasztása tömbből feltétel szerint;

Egy tömb véletlenszerű kitöltése.

Egy tömbbel való munka megkezdéséhez ki kell tölteni, pl. tömbelemekhez rendeljen bizonyos értékeket. Véletlenszámok sorozatának létrehozásához használja a Random(100) függvényt. A program futtatásakor ez a függvény 0 és 100 közötti egész számok pszeudo-véletlenszerű sorozatát jeleníti meg.

Egymástól eltérő véletlenszám-sorozatok generálásához ajánlatos a Randomize operátort használni

Műveletek egydimenziós tömbökkel

1. Elemek összegének kiszámítása

I:= 1-től 10-ig: s:=s+ a[i]; (szokásos összeg felhalmozódása s-ban)

2. A termék kiszámítása

I:= 1-től 10-ig Do p:=p* a[i]; (szokásos termékfelhalmozás p-ban)

3. Adott értékű elem keresése

3. Megjegyzés készségek és képességek megváltoztatása a gyakorlatban

Projekt „Elemek összege egy tömbben”. Fejlesszük ki az „Elemek összege egy tömbben” projektet, amely kitölti a tömböt véletlenszerű számokkal, és kiszámítja ezeknek a számoknak az összegét

Először hozzunk létre egy tömbkitöltési eljárást.

1.Indítsa el a Delphi programozási rendszert.

2. A projekten végzett munka a létrehozással kezdődik GUI, erre az ablakban Űrlapkészítő vezérlőelemek kerülnek az űrlapra. A projekt grafikus felületének elkészítéséhez az űrlapon két szövegmezőt helyezünk el a numerikus adatok megjelenítésére (az egyik a tömb kitöltésére, a másik az összeg megjelenítésére), valamint két gomb az eseményeljárások megvalósítására: a tömb kitöltése és az összeg.

3. Használata Eszköztárak helyezzen el egy Editl szövegmezőt és egy Buttonl parancsgombot a Forml űrlapon

A következő lépés az eseményeljárások kódolása. Ha duplán kattint arra a gombra, amelyhez programkódot szeretne létrehozni, megjelenik az ablak Programkód egy üres eseményeljárás csonkkal.

4. Kattintson duplán a Buttonl gombra, megjelenik a TForml.ButtonlClick eseményeljárás csonkja: Tömb deklarálása Aés a változók leírása Én, S a var deklaráció részben

A: egész számok tömbje;

eljárás TForm1.Button1Click(Sender: TObject);

I:= 1-től 10-ig

A[I] := Véletlenszerű(10);

Edit1.Text:= Szerkesztés1.Szöveg +" " + IntToStr(a[i]);

5. Projekt mentése másként

6. Projekt összeállítás (Project - Compile)

Most hozzunk létre egy eljárást a kitöltött tömb elemeinek összegének kiszámítására

Használva Eszköztárak p Helyezzük el a Button2 gombot és a Szerkesztés2 szövegmezőt a Forml űrlapon. Ha duplán kattint arra a Button2 gombra, amelyhez programkódot szeretne létrehozni, megjelenik az ablak Programkód egy üres eseményeljárás csonkkal.

eljárás TForm1.Button2Click(Sender: TObject);

I:= 1-től 10-ig

Edit2.Text:= Edit2.Text +" " + IntToStr(s)

A teljes projekt projektjének mentése (Projekt mentése).

Állítsuk össze a projektet (az F9 billentyű lenyomásával).

Kattintson a Kitöltés tömb és Összeg gombokra.

A szövegmezőben megjelennek a különböző kitöltési lehetőségek összegeinek eredményei.

4. Összegzés

5. Házi feladat: Hozzon létre egy projektet „A tömbelemek szorzata”, amely biztosítja a tömb kitöltését véletlen számok valamint a tömb összes elemének szorzatának a szövegmezőben való megjelenítésének lehetősége.

Megtanuljuk a tömb fogalmát, a tömbök rendszerezésének módjait az algoritmusokban és programokban, a tömbök kitöltésének módjait, a tömbök típusait és méretét. Megtanuljuk megoldani a legegyszerűbb feladatokat, feladatokat a feltételnek megfelelő elemek megtalálására.

Az óra célja: megadni a tömb fogalmát, tömbök rendszerezésének módjait algoritmusokban és programokban, tömbök kitöltésének módjait, tömbök típusait és méretét, megtanulni egyszerű feladatok megoldását, feladatokat feltételnek megfelelő elemek megtalálására, feladatok megoldását bemutatni tömbök rendezése.

Az órák alatt:

1. Az új anyag magyarázata:

A számítógépben történő adatgyűjtés és -feldolgozás problémáinak megoldásában fontos szerepet játszanak az adattömbök és szekvenciák. véletlen hozzáférésű memória vagy mágneses adathordozón.

A tömb a memória egy olyan régiója, amely egy bizonyos típusú adatgyűjteményt tartalmazhat.

A tömbök egyes elemeinek kijelöléséhez indexeket kell megadni.

A tömbök leírása:

• Típus (változótípusok ismétlése, analógia tömbökkel: valós, egész %, karakter $, logikai)
• Tömbméretek (egydimenziós-lineáris, kétdimenziós-téglalap alakú stb.)

Mivel a tömbök adatok aggregátumait tárolják, ezeket ciklusok segítségével dolgozzák fel.

alg"Szorzótábla"
korai
tól től K=1 előtt 9 ciklus
tól től L=1 előtt 9 ciklus
T=K*L
kcycle
kcycle
con

T - kétdimenziós tömb (hurok a hurkon belül)
L-alakú sorok- belső hurok
k-módosítja a sorindexet

alg"szorzótábla megjelenítése"
korai
tól től K=1 előtt 9 ciklus
tól től L=1 előtt 9 ciklus
T terminál
Kcycle
Kimenet (újsor)
kcycle
con

a belső hurok szervezi a karakterláncok kimenetét
külső - táblázatot képez (oszlopok)

A tömbök feltöltésének módjai

1. a billentyűzetről
2. az MHD-n tárolt információk átírása
3. képlet
4. véletlenszám generátor
5. adatokat, olvassa el

Táblázat értékek

Az egydimenziós tömb listának, a kétdimenziós tömb táblázatnak felel meg. Mielőtt ezeket a programban használná, meg kell adnia a gépet, hogy az előre helyet foglaljon

Dim (dimenzió)

Dim (8) Dim (8, 15)

A méret nullától számítva.

A Dim a program elejére kerül.

A tömbök feltöltésének módjai

1. a billentyűzetről

dimA(3,4)
I=1-től 3-ig
j=1-től 4-ig
bemenet A(I,J)
következő J,I

2. képlet

dimA(3)
I=1-től 3-ig
A(I)=cos(I)
következő I

3. véletlenszám-generátor

dimB(7)
I=0 és 7 között
A(I)=int(rnd(1)*100+1)
következő I

4. adatok, olvasás

dimA$(4)
I=1-től 4-ig
olvasni A$(I)
? A$(I)
következő I
adatok Lena, Olya, Katya, Kolya

d/h: absztraktok

Szakaszok: Számítástechnika

Tantárgy: Kétdimenziós tömbök. Kétdimenziós tömb kitöltése adott szabály szerint.

Célok: fejleszti a kétdimenziós tömb elemeivel való munkavégzés készségeit, megtanulja a kétdimenziós tömbök adott szabály szerinti kitöltését, megtanulja a sorszám és az oszlopszám közötti összefüggés származtatását; a tanulók logikus gondolkodásának fejlesztése.

TANULMÁNYI FOLYAMAT

1. Tudásfrissítés

Azokat a tömböket, amelyekben az elemek helyzetét két index írja le, kétdimenziósnak nevezzük. Egy ilyen tömb szerkezete egy téglalap alakú mátrixszal ábrázolható. A mátrix minden eleme egyedileg azonosítható a sor- és oszlopszámok feltüntetésével, a sorszám i, az oszlop száma j.
Tekintsünk egy n*m méretű A mátrixot:

egy 11	egy 12	egy 13	egy 14
a 21	a 22	a 23	a 24
egy 31	egy 32	egy 33	egy 34

3 soros és 4 oszlopos mátrix, sorok száma n=3, oszlopok száma m=4. Minden elemnek megvan a saját száma, amely két számból áll - annak a sornak a számából, amelyben az elem található, és az oszlop számából. Például a23 a második sor és a harmadik oszlop eleme.
A Turbo Pascal kétdimenziós tömbje többféleképpen írható le. Egy kétdimenziós tömb leírásához meg kell határozni, hogy milyen típusú elemei vannak, és hogyan vannak számozva (milyen típusú az indexe). A kétdimenziós tömb leírásának többféle módja van.

Állandó maxN=…; (Maximális sorértékek)
maxM=…; (Maximális oszlopszám értékek)

1 út

Típus Mas = array of<тип элементов>; (egydimenziós tömb)
Timas típus = Mas tömbje; (Egydimenziós tömb, amelynek elemei egydimenziós tömbök)

2 út

Írja be: Tmas = array of array of<тип элементов>;
(Egydimenziós tömb, amelynek elemei egydimenziós tömbök)

3 út

típus<имя типа>= tömb<тип элементов>; (Kétdimenziós tömb)

Előnyben részesítjük a kétdimenziós tömb leírásának harmadik módját.

Például:

ConstN=3; M=4;
Típus: Tmas= egész számok tömbje; (Egész számok kétdimenziós tömbje)

A kétdimenziós tömb kialakítása négyféleképpen történhet: bevitellel a billentyűzetről, véletlenszám-generátoron keresztül, adott szabály szerint, vagy fájl segítségével.

1) Kétdimenziós tömb kialakítása a billentyűzet bevitelével és a mátrixelemek soronkénti kimenetének algoritmusával.

Állandó N=10;M=10;
Type Tmas= egész számok tömbje;
VarA:Tmas; i,j:integer;
Kezdődik
(mátrixelemek bevitele)
Az i:=1-től N-ig tegye
j:=1-től M-ig tegye
Olvasni egy);
(A mátrixelemek kimenete)
Az i:=1-től N-ig kezdje
j:=1-től M-ig tegye
Írás(A:4); (Az első sor nyomtatva)
Writeln (új sor)
vége;
vége.

2) A véletlenszám-generátoron keresztül kétdimenziós tömböt generáló program töredéke.

Kezdődik
randomizálni; (Véletlenszám-generátor inicializálása)
(mátrixelemek bevitele)
Az i:=1-től N-ig tegye
j:=1-től M-ig tegye
A:=random(45)-22;

2. Új anyag elsajátítása. Tömb kitöltése szabály szerint

Tekintsünk több programtöredéket egy kétdimenziós tömb kitöltésére egy bizonyos törvény szerint. Ehhez le kell vezetnie egy kitöltési szabályt.

1. Töltse ki az A tömböt n*m-es mérettel, például az alábbiak szerint

1 2 3 4 5 6 7 8
16 15 14 13 12 11 10 9
17 18 19 20 21 22 23 24
32 31 30 29 28 27 26 25
33 34 35 36 37 38 39 40
48 47 46 45 44 43 42 41

A tömb kitöltése a "kígyó" elv szerint történik. Kitöltési szabály: ha a sorszám páratlan, akkor A=(i-1)*m+j, egyébként A=i*m-j+1.

program M1A;

n,m,i,j: egész szám;
kezdődik
readln(n,m);
az i:=1-től n-ig kezdődik
j:=1-hez m do
kezdődik
ha i mod 2 = 1 akkor
A=(i-1)*m+j
más
A=i*m-j+1;
írás(A:3);
vége;
írásban;
vége;
readln;
vége.

Íme egy példa egy másik kitöltési módra egy adott szabály szerint:

program M1B;
varA:egész számok tömbje;
n,m,i,j: egész szám;
c: egész szám;
kezdődik
readln(n,m);
c:=1;
i:=1-től n-ig
kezdődik
j:=1-hez m do
kezdődik
A:=c;
ha (i mod 2 = 0) és (j<>m) akkor
dec(c)
más
inc(c);
írás(A:3);
vége;
c:=c+m-1;
írásban;
vége;
readln;
vége.

2. Töltse ki az A tömböt a következő elv szerint:

1 0 2 0 3 0 4
0 5 0 6 0 7 0
8 0 9 0 10 0 11
0 12 0 13 0 14 0

program M2;
varA:egész számok tömbje;
n,m,i,j: egész szám;
c: egész szám;
kezdődik
readln(n,m);
c:=0;
i:=1-től n-ig
kezdődik
j:=1-hez m do
kezdődik
ha (i-1+j) mod 2 = 0 akkor
A:=0
más
kezdődik
inc(c);
A:=c;
vége;
írás(A:5);
vége;
írásban;
vége;
readln;
vége.

3. Töltse ki az A tömböt a következő elv szerint:

1 12 13 24 25 36
2 11 14 23 26 35
3 10 15 22 27 34
4 9 16 21 28 33
5 8 17 20 29 32
6 7 18 19 30 31

varA:egész számok tömbje;
n,m,i,j: egész szám;
c: egész szám;
kezdődik
readln(n,m);
c:=1;
j:=1-hez m do
kezdődik
i:=1-től n-ig
kezdődik
A:=c;
ha (j mod 2 = 0) és (i<>n) akkor
dec(c)
más
inc(c);
vége;
c:=c+n-1;
vége;
i:=1-től n-ig
kezdődik
j:=1-hez m do
írás(A:5);
írásban;
vége;
readln;
vége.

4. Töltse ki az A tömböt a következő elv szerint:

1 2 3 4 5
2 3 4 5 1
3 4 5 1 2
4 5 1 2 3
5 1 2 3 4

var i,j,m,c,d: egész szám;

kezdődik
c:=1;
readln(m);
j:=1-hez m do
kezdődik
i:=c;
d:=1;
ismétlés
A:=d;
inc(i);
ha i>m akkor
i:=1;
inc(d);
amíg i=c;
dec(c);
ha c<= 0 then
c:=m-c;
vége;
for i:=1 to m do
kezdődik
j:=1-hez m do
írás(A:2);
írásban;
vége;
vége.

5. Töltse ki az A tömböt a következő elv szerint:

1 0 0 0 1
0 1 0 1 0
0 0 1 0 0
0 1 0 1 0
1 0 0 0 1

var m,i,j: egész szám;
A: egész számok tömbje;
kezdődik
readln(m);
for i:=1 to m do
kezdődik
j:=1-hez m do
kezdődik
ha (i=j) vagy (m-i+1=j) akkor
A:=1
más
A:=0;
írás(A:2);
vége;
írásban;
vége;
vége.

3. Önálló megoldási feladatok

6 5 4 3 2 1
7 8 9 10 11 12
18 17 16 15 14 13
19 20 21 22 23 24
30 29 28 27 26 25
31 32 33 34 35 36

36 25 24 13 12 1
35 26 23 14 11 2
34 27 22 15 10 3
33 28 21 16 9 4
32 29 20 17 8 5
31 30 19 18 7 6

0 1 1 1 0
1 0 1 0 1
1 1 0 1 1
1 0 1 0 1
0 1 1 1 0

4) Töltse ki a tömböt a következő elv szerint:

31 32 33 34 35 36
25 26 27 28 29 30
19 20 21 22 23 24
13 14 15 16 17 18
7 8 9 10 11 12
1 2 3 4 5 6

5) Töltse ki a tömböt a következő elv szerint:

31 25 19 13 7 1
32 26 20 14 8 2
33 27 21 15 9 3
34 28 22 16 10 4
35 29 23 17 11 5
36 30 24 18 12 6

Házi feladat:

1) Töltse ki a tömböt a következő elv szerint:

6 7 18 19 30 31
5 8 17 20 29 32
4 9 16 21 28 33
3 10 15 22 27 34
2 11 14 23 26 35
1 12 13 24 25 36

2) Töltse ki a tömböt a következő elv szerint:

31 32 33 34 35 36
30 29 28 27 26 25
19 20 21 22 23 24
18 17 16 15 14 13
7 8 9 10 11 12
6 5 4 3 2 1

3) Töltse ki a tömböt a következő elv szerint:

0 1 1 1 0
1 0 1 0 1
1 1 0 1 1
1 0 1 0 1
0 1 1 1 0

Eddig egyszerű adattípusokkal dolgoztunk - logikai (logikai), integer (integer , word , byte , longint), valós (real), karakteres (char). Ezzel a négy alaptípussal bármilyen algoritmus programozható. A sokszínű valós világgal kapcsolatos információk feldolgozásához azonban összetettebb szerkezetű adatokra van szükség. Az ilyen, a legegyszerűbb skalártípusokon alapuló összetett konstrukciókat struktúráknak nevezzük. A struktúra néhány összetett adattípus, amely alapvető skaláris adattípusokból áll. Ha a struktúra nem változtatja meg szerkezetét a program végrehajtása során, amelyben le van írva, akkor az ilyen struktúrát statikusnak nevezzük.

A tömb az elemek homogén gyűjteménye

A szinte minden programozási nyelvben megvalósított leggyakoribb struktúra egy tömb.

A tömbök korlátozott számú komponensből állnak, és minden tömbkomponens azonos típusú, az úgynevezett alaptípus. Egy tömb szerkezete mindig homogén. Egy tömb tartalmazhat integer , real vagy char típusú elemeket, vagy más, azonos típusú elemeket. Ebből azonban nem szabad azt a következtetést levonni, hogy a tömbkomponensek csak skalár típusúak lehetnek.

A tömb másik jellemzője, hogy bármely összetevője tetszőlegesen elérhető. Mit jelent? A program sorszáma (index) alapján azonnal megkaphatja a számára szükséges elemet.

Tömb index

A tömb elemszámát hívják index. Az index egy sorszámú érték, amely ként van definiálva index típus adott tömböt. Nagyon gyakran ez egy egész szám (integer , word vagy byte), de lehet logikai és karakteres is.

Egy tömb leírása Pascalban. Pascalban a tömb típusát egy speciális szó segítségével adjuk meg sor(angolul - tömb), és a deklarációja a programban a következő:

típus< имя _ типа >= T tömb [ I ];

ahol I a tömbindex típusa, T az elemeinek típusa.

Azonnal leírhatja a tömb típusú változókat, pl. a változó deklaráció részében:

Var a,b: T tömb [ I ];

Általában egy indextípust bármely sorszámú érték bizonyos tartománya jellemez: I 1 .. I n . Például az indexek 1...20 vagy " a ".." n " tartományban változhatnak.

A Pascal tömb hosszát a következő kifejezés jellemzi:

ord (I n)- ord (I 1)+1.

Például itt van egy kétféle deklaráció: a vektor 10 egész számból álló Pascal-tömbként és a stroka 256 karakterből álló tömbként:

típus
Vector=egész számok tömbje;
string=karakter tömb;

Egy tömbindex segítségével bármely tömb egyes elemeit reguláris változóként érheti el: ennek az elemnek az értékét megkaphatja, külön-külön hozzárendelheti értékét, felhasználhatja kifejezésekben.

Leírjuk a vektor és karakterlánc típusú változókat:

Pascal tömb index számítása

A Pascal tömb indexét nem kell kifejezetten beállítani. Tömbindexként használhatunk az index típusának megfelelő változót vagy kifejezést. Más szóval, az indexek kiszámíthatók.

Ez a mechanizmus egy nagyon hatékony programozási eszköz. De generál egy általános hibát: előfordulhat, hogy a számítás eredménye kívül esik a megengedett indexértékek tartományán, vagyis olyan elemre próbálnak hivatkozni, amely nem létezik. Ezt a gyakori hibát "határon kívüli tömbnek" nevezik.

Példaprogram Pascal tömbhibával

Program primer _ error ;
típus
vektor=szótömb;
var
n: egész szám
a:vektor;
kezdődik
n = 45;
a:=25;
vége.

Habár ez a program teljesen megfelel a nyelv szintaxisának, és a fordító "kihagyja", futási időben hiba lép fel a Pascal tömb határainak túllépése miatt. Ha n =45, az n *2=90 kifejezés, a számítógép megpróbál hozzáférni az a tömbelemhez, de nincs ilyen elem, mivel egy 80 dimenziós tömb van leírva.

Ezt feltételezzük jó program figyelmeztető üzenetet kell kiadnia, ha nem létező tömbelemekhez próbál hozzáférni. Nem lenne felesleges ellenőrizni a lehetséges kilépést mind a jobb, mind a bal tömbhatárnál, mert lehetséges, hogy a kifejezés értékének kiszámítása eredményeként olyan számot kapunk, amely a Pascaltól balra van. tömbhatár.

Mindebből azt a következtetést vonhatjuk le, hogy a programozónak nagyon óvatosnak kell lennie, amikor tömbindexekkel dolgozik.

Alapvető műveletek Pascal tömbökkel

Mint ismeretes, az adattípus meghatározása azt jelenti, hogy korlátozzuk a megengedett értékek tartományát, a számítógépen belüli megjelenítést, valamint az ilyen típusú adatokon megengedett műveletek készletét. Az adattípust Pascal tömbként határoztuk meg. Milyen műveletek vannak meghatározva ezen az adattípuson? Az egyetlen művelet, amely teljes tömbökön végrehajtható, és csak akkor, ha a tömbök azonos típusúak, a hozzárendelés. Ha a program két azonos típusú változót deklarál, pl.

Var
a , b: valós tömb ;

akkor változtathatsz aértéket rendel egy változóhoz b(a:= b). Ebben az esetben a tömb minden eleme a a megfelelő értéket kapja a tömbből b. A Pascal-tömbök összes többi műveletét elemenként hajtják végre. (fontos!) .

Pascal tömb bemenet

A tömbelemek értékeinek megadásához szekvenciálisan módosítani kell az indexértéket, az elsőtől az utolsóig, és be kell írni a megfelelő elemet. Ezen műveletek végrehajtásához célszerű egy adott számú ismétlést tartalmazó hurkot használni, pl. egy egyszerű aritmetikai ciklus, ahol a ciklus paramétere egy változó lesz - a Pascal tömb indexe. Az elemértékek beírhatók a billentyűzetről, vagy meghatározhatók hozzárendelési operátor segítségével.

Példa Pascal tömb bemeneti programtöredékére

Var
A: egész számok tömbje ;
Kezdődik
Az i:=1-től 10-ig tegye
readln(a[i]); (az i-edik elem bevitele a billentyűzetről történik)

Tekintsük most azt az esetet, amikor a Pascal tömb automatikusan véletlen számokkal van kitöltve, ehhez a függvényt használjuk véletlen(N).

Példa egy programrészletre Pascal-tömb véletlen számokkal való kitöltésére

Var
Én: bájt (az I változó tömbindexként kerül megadásra)
Kezdődik
Az i:=1-től 10-ig tegye
A[i]:= véletlen(10); (A tömb i-edik eleméhez egy "véletlenszerű" egész szám van hozzárendelve a 0 és 10 közötti tartományban)

Pascal tömb kimenet

A Pascal-ban egy tömb kimenete szintén elemenként, ciklusban történik, ahol a tömb indexe paraméterként működik, és az elsőtől az utolsóig veszi az összes értéket.

Példa Pascal tömb kimeneti programtöredékére

Var
A: egész számok tömbje;
Én: bájt (az I változó tömbindexként kerül megadásra)
Kezdődik
Az i:=1-től 10-ig tegye
Write(a[i]," "); (a tömb kimenete sztringben történik, minden elem után szóköz kerül kinyomtatásra)

A következtetés a megfelelő indexet jelző oszlopban is levonható. De ebben az esetben figyelembe kell venni, hogy nagy tömbméret esetén előfordulhat, hogy nem fér el minden elem a képernyőn, és görgetés történik, pl. ha a képernyő minden sora megtelt, a következő elem kerül kinyomtatásra, a felső pedig elmozdul a képernyőről.

Példaprogram Pascal tömb oszlopban való megjelenítésére

Var
A: egész számok tömbje;
Én: bájt (az I változó tömbindexként kerül megadásra)
Kezdődik
Az i:=1-től 10-ig tegye
WriteIn("a[", i,"]=", a[i]); (kimeneti tömbelemek egy oszlopban)

A képernyőn például a következő értékeket fogjuk látni:

a=2
a=4
a =1 stb.

Példa egy probléma megoldására Pascal tömbök használatával

Feladat: adott két n-dimenziós vektor. Határozzuk meg ezeknek a vektoroknak az összegét!

A probléma megoldása:

• A probléma bemenete két egydimenziós tömb lesz. Ezen tömbök mérete tetszőleges, de biztos lehet. Azok. szándékosan nagy tömböt írhatunk le, és a programban határozzuk meg, hogy valójában hány elemet használunk. Ezen tömbök elemei lehetnek egész számok. Akkor a leírás így fog kinézni:
  

  var a , b: egész szám tömbje;

• A kimenet a kapott tömb elemei lesznek, nevezzük c -nek. Az eredményül kapott tömb típusának is egész számnak kell lennie.
• Három tömb mellett szükségünk van egy változóra - egy hurokparaméterre és egy tömbindexre, nevezzük i -nek, valamint egy n változóra az egyes tömbök elemszámának meghatározásához.

A probléma megoldásának menete:

• határozza meg a tömbök elemeinek számát (dimenzióját), írja be az n értéket;
• írjunk be egy tömböt a ;
• írja be a b tömböt;
• egy hurokban, az i index értékeit 1-től n-ig rendezve, egymás után kiszámítjuk a c tömb elemeinek értékeit a következő képlet szerint:

  c[i] = a[i]+ b[i];

• jelenítse meg az eredményül kapott tömböt.

A program szövege:

Egy példaprogram vektorok összegzésére

program összege;
Var
a, b, c: egész számok tömbje;
I, n: bájt;
Kezdődik
Write("Adja meg a tömb méretét:");
readln(n);
Az i:=1-től n-ig tegye
readln(a[i]); (tömbbemenet a)
Az i:=1-től n-ig tegye
readln(b[i]); (b tömb bemenet)
Az i:=1-től n-ig tegye
C[i]:=a[i]+b[i]; (a tömbök összegének kiszámítása)
Az i:=1-től n-ig tegye
write(c[i]," "); (tömb kimenet a következővel)
vége.