Pascal programozási bemutató. Programozási nyelv Pascal

PASCAL BEVEZETÉS A PROGRAMOZÁSI NYELVBE 2006 A TANFOLYAM FELÉPÍTÉSE Interfész és főbb definíciók; programstruktúra; szöveges információk megjelenítése; billentyűzet bemenet; rendszermodulok csatlakoztatása és használata; alapvető adattípusokkal (egész, valós, karakterlánc, tömb, fájl) dolgozni, grafikával dolgozni; szubrutinok (eljárások és funkciók) használata; modulok használata. 2 A PASCAL KÖRNYEZET FELFÜSZE Programozási nyelv TurboPascal 7.0 szerszámozott. Tartalmaz: több ablakos szövegszerkesztőt; program linker; programhibakereső; súgórendszer; fordítóprogram. 3 PASCAL ENVIRONMENT INTERFACE 4 Megnyitott fájlok listája: Alt + 0 Gyors hozzáférés a megnyitott fájlokhoz: Alt +<№ окна> ALAPVETŐ DEFINÍCIÓK A fenntartott szó egy speciális szó, amelyet a programozási nyelv a program logikai területeinek elkülönítésére használ. Az operátor egy nyelvi parancs, amely valamilyen műveletet hajt végre (feltétel ellenőrzése, ciklus szervezése stb.) Az azonosító egy programozó által szabadon választott név a programelemekhez. Az adattípus egy azonosító jellemzője, amely meghatározza az általa felvehető értékkészletet (egész vagy tört számok, karakterláncok, logikai kifejezések stb.). 5 A PROGRAM ÁLTALÁNOS FELÉPÍTÉSE Program Programnév; A beépülő modulok szakaszát használja; A címkék címkeleíró része; Az állandók deklarációjának Const szakasza; A natív adattípusokat leíró típusszakasz; Var változó deklarációs szakasz; Kezdés A program fő része; vége. Minimális kód: 6 KÉPERNYŐKIMENET Az információk képernyőn való megjelenítéséhez a következő operátorokat kell használni: Write vagy Writeln. F9 - Fordítás + ellenőrzés Ctrl+F9 - F9 futtatása → Ctrl+F9 - Hibák elkerülése Programvégrehajtás eredményének megjelenítése 7 SCREEN OUTPUT Az utasítások eredménye: WRITE "Üres" A WRITELN utasítás üres karakterláncot ad hozzá WRITELN 8 GYAKORLAT Információk megjelenítése a képernyőn az alábbiak szerint Hello! Örülök, hogy látlak! hívj számítógépet. Felhasznált anyag: Kimeneti utasítások: Write, WriteLn "Üres" operátor WriteLn; beszúr egy üres karakterláncot. 9 TOVÁBBI MODULOK CSATLAKOZTATÁSA A további modulok további operátorok bevezetésével bővítik a programjainak képességeit. A modulok csatlakoztatása a Felhasználások részben történik. ProgramMy; Modul1, Module2 ; ____________________________ ___________________________________ ________________________________ _____________________________ 1. MODUL 1. erőforráskészlet … N MODUL Modulok: Rendszer saját erőforráskészlet N Szövegképernyő törlése Várakozás billentyűlenyomásra Csatlakoztatott CRT 10 nevű modul RANDOM SCREENX OUTteger (X VÉLETLENSZERŰ KÉPERNYŐ X, YPUT) koordináta a képernyőn. X értéket vehet fel 1-től 80-ig, Y pedig 1-től 25-ig. Például: Program Saját_program; (Modul csatlakozás) Crt-t használ; Kezdés (Képernyő törlése) ClrScr; (adatkimenet) GotoXY(1, 1); write("▒"); GotoXY(80; 1); write("▒"); GotoXY(1; 25); write("▒"); GotoXY(80; 25); write("▒"); (képernyő késleltetése) ReadKey; vége. A program a „▒” szimbólumot (177-es kód) jeleníti meg a képernyő sarkaiban. 11 KIMENETI SZÍNES TextColor (Színes); Meghatározza a karakterek színét. TextBackground (Színes); Meghatározza az ismerős színét. ProgramMyProgram; crt-t használ; Kezdje TextColor(Piros); TextBackGround (kék); Write("Kívül"); Szövegszín (fehér); Write("fű, "); Szövegszín (zöld); TextBackGround(sárga); Write("a fűben"); TextBackGround (bíbor); Write("tűzifa. vége lila - barna - világosszürke - sötétszürke - kék - világoszöld - világos cián - rózsaszín - világos lila - sárga - fehér ÉRTÉKEK Adatműveletek AZONOSÍTÓK Az azonosító kifejezés konstansokra, változókra, függvényekre, eljárásokra, összetevőkre és más, felhasználó által meghatározott objektumok Engedélyezett karakterek: latin betűk, számok, aláhúzás Korlátozások: Nem kezdődhet számjeggyel, de kezdődhet aláhúzással. Nem lehet több szó Nem egyezhet a kulcsszavakkal Az azonosítók nem különböztetik meg a kis- és nagybetűket . Hibás azonosítók: Adatok Saját nevem 2Array Var ( ( ( ( orosz karaktereket használnak ) Szóköz van ) Számmal kezdődik ) A kulcsszónak felel meg ) számok, karakterláncok, logikai kifejezések stb.). 16 INTEGER DATA TYPE 17 A lehetséges értékek véges halmaza Type byte shortint word integer longint range 0..255 -128..127 0..65535 -32768..32767 -2147483648..2147483647 ! A tartományon kívül eső hibát eredményez! méret VÁLTOZÓK DEKLARÁCIÓJA A változó olyan azonosító, amely képes valamilyen értéket (számot, karakterláncot stb.) tárolni és a program működése során megváltoztatni. Szintaxis: Var<имя переменной> : <тип переменной>; Program program_neve; A beépülő modulok szakaszát használja; Var változó deklarációs szakasz; Kezdés A program fő része; vége. A számítógép memóriájában 3 változó számára fenntartott hely 18 ÉRTÉKEK BEÁLLÍTÁSA VÁLTOZÓKHOZ Egy változó értékének beállításához a hozzárendelési operátort kell használni:= Record szintaxis:<Переменная> := <Значение>; A 3-as értéket az A nevű változóba (egész szám) írjuk be 19 MŰVELETEK EGÉSZ SZÁMÚ VÁLTOZÓKKAL 20 Aritmetikai műveletek: + - * / Szabványos műveletek: div | mod | sqr Nem használható egész típusokkal Az S nevű változó az X és Y változókban tárolt értékek összegére van beállítva Az S nevű változóban tárolt érték megjelenik a képernyőn 21. GYAKORLAT 1. Írjon egy programot, amely megjeleníti a a 15 és 20 számok szorzásának eredménye 2. Írjon programot, amely kiírja az f 2 x 3 y függvény értékét, ha x=11, y=3 Felhasznált anyag: A változók deklarálása a Var szekcióban Az egész típus neve Integer A változóhoz való érték hozzárendelésének szintaxisa a következő:<Переменная> := <Значение> ; Minden operátor után egy tábla kerül elhelyezésre; (kivéve az elejét és az utolsó végét) VALÓS ADATTÍPUS Értékkészlet √ √ Sorrend típusú Valós típus Egyirányú kompatibilitás: Valós egész Valós! A tartományon kívül eső és a kompatibilitási szabályok be nem tartása hibához vezet! 22 MŰVELETEK VALÓS VÁLTOZÓKKAL 23 Standard műveletek: pi | Négyzet | bűn | Cos | hasizom | exp | Ln Round | Csonka (valós → egész) Például (X, S – Valós típus): X:= pi/3; S:= Sin(X)*100; Write(Round(S)); Az X és Y változókban tárolt értékek aránya egy S nevű változóba kerül. A szám pozíciója és a karakterek száma az E szám tört részében a szám hatványát jelzi. 5.6E-5 = 5.6·10-5 STRING DATA TÍPUS 24 A karakterláncok rendezett karakterkészletek. A húrok aposztrófokba vannak zárva. A karakterláncok nem kompatibilisek az egész és valós típusokkal. Típus Tartomány Karakterlánc 255 karakter ( Basic string operátorok ) + ( összefűzés ) Hossz (S); ( karakterlánc hossza ) Például: X:= 'Vasya'; Write('A te nevedben', Hossz(X), 'lit.'); S:=X; X:=S; GYAKORLAT Írjon programot, amely a 12,89 és 0,22 számok elosztásának eredményét a tizedesvessző után csak három jelentős számjeggyel jeleníti meg a következő formátumban: első szám osztva második számmal = eredmény Írja (X:1:3, ' razdelit na ' , y:1 :3, ' = ' z:1:3) Felhasznált anyag: A karakterlánctípus neve String A karakterláncok utójelek közé vannak zárva A karakterláncok + jellel vannak összefűzve A megjelenítési utasításban a különböző típusokat vessző választja el 25 KEYBOARD BEMENET 26 Ahhoz, hogy információkat adjon meg a billentyűzetről, a beviteli operátort kell használnia: Read vagy ReadLn. Szintaxis: Olvasás (N1, N2, ... Nn); Ahol N1, N2, ... Nn változók (egész, valós, karakterlánc) Az X változóban a billentyűzetről beírt érték kerül beírásra Az érték megadása után meg kell nyomni az Enter billentyűt Ha több változó van a az operátort, szóközzel elválasztva vagy billentyű lenyomásával írhatók be Enter 27. GYAKORLAT 1. Írjon egy mini számológépet, amely kiszámolja a billentyűzetről beírt két szám összegét. 2. Írjon egy programot, amely megkérdezi a nevét, és miután beírta a nevét, megjelenik egy üdvözlő üzenet. Például, ha beírtad a Ványa nevet, akkor a program a következő kifejezést jeleníti meg: Hello, Vanya!!! Felhasznált anyag: Bemeneti utasítások: Read, ReadLn OPERATORS FELTÉTELES OPERATOR 29 A feltételes operátor „elágazást” valósít meg, azaz megváltoztatja az operátorok végrehajtási sorrendjét valamely feltétel igazságának vagy hamisságának függvényében. Állapotellenőrzés NEM 1. teendő Kimegyek a strandra Esik az eső IGEN 2. akció Esernyőt viszek 3. akció Elmegyek moziba ELLENŐRIZNI A FELTÉTELEKET Összehasonlítási műveletek: > - tovább< - меньше = - равно >= - nagyobb vagy egyenlő<= - меньше или равно <>- nem egyenlő 30 Logikai műveletek: Nem És Vagy - Nem -És - Vagy Például: Ha a magasságom > Petya magassága, Akkor magasabb vagyok Petyánál Ha (esik az eső) Vagy (esik a hó), akkor maradok főoldal Ha Nem ((esik ) ÉS (szél)), akkor elmegyek sétálni Logikai műveletek használatakor a feltételek zárójelben vannak.<условие>akkor<оператор>; Például, ha az X változó értéke kisebb, mint 0, akkor az 1-es érték ugyanahhoz a változóhoz lesz írva: Ha X<0 Then X:= 1; Полная форма: If <условие>akkor<оператор_1>más<оператор_2>; Például: Ha X>5 Akkor X:= X - 1 Különben X:= X + 1; Csak egy operátor használható az Akkor és más szavak után Az Else szó előtt jel; hiányzik 31 32. GYAKORLAT 1. Írjon programot, amely egy bemeneti összeget kap dollárban és egy összeget euróban, majd megjeleníti, hogy melyik pénznemben nagyobb az összeg (1 dollár = 28 rubel, 1 euró = 35 rubel) 2. Írjon programot , amely három számot vesz be bevitelként, majd ezek közül a maximumot jeleníti meg. Felhasznált anyag: A feltételes operátor formái: Ha<условие>Akkor<оператор>; Ha<условие>Akkor<оператор_1>Más<оператор_2>; Mielőtt Else jel; nincs beállítva Összehasonlítási műveletek: >< = <> >= <= Логические операции: Not Or And ОПЕРАТОРНЫЕ СКОБКИ Если после слов Then или Else необходимо записать несколько операторов, то их заключают в операторные скобки (составной оператор). Операторные скобки начинаются словом Begin, а заканчиваются словом End; Например: If Z >0 Ezután kezdődik X:= 1; Y: = -1; WriteLn('Információ elfogadva'); End Else WriteLn('Hiba'); 33 CASE SELECT OPERATOR A choice utasítás a beágyazott feltételes utasítás-konstrukciók lecserélésére szolgál. Kis- és nagybetűs írásmódok szintaxisa<порядковая_переменная>nak,-nek<значение_1> : <оператор_1> ; <значение_2> : <оператор_2> ; ……… <значение_N> : <оператор_N>Más<оператор_N+1>; vége; Használhat zárójelet a select utasításban Opcionális karakterlánc 34 SELECT STATEMENT CASE Case Diák magassága 16..30: Általános iskolás vagy; 31,32,33: 5-6 osztályba jársz; 34..50: Ön gimnazista. A vessző az értékek felsorolására, kettőspont a tartomány kiválasztására szolgál. Különben Ön egyértelműen nem diák; vége; -128..-1 x esete: writeln('Negatív'); 0: writeln('Nul'); 1..127: writeln('Pozitív') Else WriteLn('Tartományon kívül'); vége; 35 GYAKORLAT Írjon programot, amely adott számmal megjeleníti a hét megfelelő napját! Például írja be a 2-es számot, a programnak a „kedd” szöveget kell kiadnia. Ha a szám kívül esik az 1..7-en, akkor egy üzenetet kell kijelezni, hogy nincs ilyen nap. Felhasznált anyag: Kiválasztó operátor: Tok<порядковая_переменная>nak,-nek<значение_1> : <оператор_1> ; ……… <значение_N> : <оператор_N>; Más<оператор_N+1>; vége; 36 CIKLUSOK 37 Ciklikusnak nevezzük azokat az algoritmusokat, amelyekben egyes operátorok végrehajtása ismétlődően ugyanazokkal a módosított adatokkal történik (például a számok többszörös összeadásán keresztüli szorzása). A Pascalban három ciklusutasítás létezik: For (ciklus egy paraméterrel vagy meghatározott számú ismétlésre) While (WHILE ciklus) Repeat (BEFORE ciklus) Ha ismert az ismétlések száma, akkor célszerű a ciklus operátort használni egy paraméter. LOOP 38 PARAMÉTERREL Hurok meghatározott számú ismétléshez növekvő vagy csökkenő paraméterértékkel For (param) := (start_value) To (end_value) Do (operator) ; Cikk törzse Megjegyzések A paraméter egész típusú; Az operátori zárójeleket hurokban használhatja; Nem módosíthatja a ciklusparamétert a ciklustörzsben; A ciklusparaméter eggyel nő; Kezdő érték > végérték, ellenkező esetben a ciklustörzs figyelmen kívül marad; A paraméter csökkentéséhez a To helyett használja a DownTo gombot. LOOP 39 PARAMÉTERTEL Írjon programot, amely egész számokat kér (a, b), ahol a := <нач_зн>Nak nek<кон_зн>Tedd<оператор>; A paraméter egész típusú (általában Integer); Az operátori zárójeleket hurokban használhatja; A ciklusparaméter eggyel nő 40 WHILE LOOP A While ciklus először teszteli a feltételt, és csak ha igaz, akkor hajtja végre a ciklus törzsét. while (feltétel) do (állítás); Az alább írt kódtörzsben a ciklus soha nem kerül végrehajtásra: x:=1; Míg x>1 az x:=x-1; Kaphat egy végtelen hurkot. Például: x:=1 Míg x>0 nem x:=x+1; 41 WHILE LOOP Program, amely az a-tól b-ig tartó számok összegét jeleníti meg. Ha nincs lenyomva, akkor a Delay(2000) kezdődik; vége; A hurok addig fut, amíg az f változó nagyobb nem lesz a b értéknél. 42 43. GYAKORLAT 1. Az űrhajósok úgy döntöttek, hogy nyírfákat telepítenek a Holdra, és minden évben megduplázzák a nyírfák számát, az első évben 3 nyírt ültettek. Nyomtassa ki a képernyőre, hogy a nyírfák száma hány év alatt haladja meg a 10 000-et 2. Írjon programot, amely meghatározza a billentyűzetről beírt számok maximumát (a számbevitel 0-ra végződik). Az alábbiakban egy javasolt képernyőelrendezés látható: Írja be a számokat. A bevitel befejezéséhez írjon be 0. 89 15 0 A maximális szám 89. Felhasznált anyag: While Loop utasítás: While<условие>csináld<оператор>; A While ciklus először teszteli a feltételt, és csak ha igaz, akkor hajtja végre a ciklus fő törzsét. REPEAT LOOP 44 A Repeat ciklus először végrehajtja a ciklus törzsét, és csak ezután ellenőrzi a Repeat (loop_body) Until feltételt (feltétel); Nincs szükség összetett utasítás használatára az Ismétlés ciklusban, mert ez a konstrukció nem egy, hanem több, a Repeat és Until szavak közé zárt utasítás végrehajtását biztosítja. REPEAT LOOP ("Addig") Olyan program, amely megjeleníti a számok összegét a-tól b-ig. A hurok addig fut, amíg az f változó nem nagyobb, mint a b érték. Szinte mindig használhatunk más típusú ciklust egy helyett FELADAT Számítsuk ki az y x 3 x 2 16 x 43 függvény értékét x esetén, amely a -4 és 4 közötti tartományban változik, 0,5 lépéssel! Felhasznált anyag: Loop utasítás Ismétlés: Ismétlés<тело_цикла>Amíg<условие>A Repeat ciklus először a ciklus törzsét hajtja végre, és csak ezután ellenőrzi a feltételt 47 CIKLUSOK MEGSZAKÍTÁSA 48 A ciklikus operátorok rugalmas vezérlésére szolgáló eljárások: Break - kilépés a ciklusból; Folytatás - a ciklus következő lépésének befejezése; Példák: Keresse meg azt a minimális i számot, amelynél az 1-től i-ig terjedő számok összege nagyobb, mint 100. Amint s (1-től i-ig terjedő számok összege) nagyobb lesz 100-nál, a break utasítás aktiválódik, és a ciklus kilép. . s:=0; I:= 1-től 100-ig akkor kezdődik, ha s>100, majd megszakad; s:= s + i; vége; Writeln ('minimális i szám, hogy (1+2+..+i)>100 egyenlő ',i); 10 számot ír be a billentyűzetről, és csak a pozitív számok összegét veszi figyelembe a ciklusban. Ha a szám negatív, akkor a folytatódik utasítás végrehajtásra kerül, amely elindítja a ciklus következő lépését. s:=0; I:= 1-től 10-ig kezdje a Readln(k); ha k<0 then Сontinue; s:= s + k; end; Writeln (‘Сумма положительных чисел равна ’,s); МАССИВЫ МАССИВЫ 50 Простые типы: одна переменная – одно значение Структурированные типы: одна переменная – несколько значений Массив – это фиксированное количество значений одного типа. Доступ к конкретному значению осуществляется через индекс. Переменная массива Структура массива: A= Доступ к массиву: 0 1 2 3 Индекс 9 7 0 0 Значения <Имя массива> [ <Индекс>] A := 7; TÖMBÖK Egy tömb deklarálva van a Var szekcióban: (Név) : Tömb [ (start_value) .. (end_value) ] of (type) ; Példák tömbdeklarációra: Var A: Array of String; B: Valódi tömb; C: Egész számok tömbje; Példák tömbök értékekkel való kitöltésére: A:='Vasya'; A:='Petya'; A:='Mása'; A:='Olesya'; Írj egy); f:=1-10 esetén C[f] := f*2; Az f:=1-től 10-ig írjon WriteLn(C[f]); 51 52. GYAKORLAT Írjon programot, amely 7 egész számot kér a felhasználótól, és eltárolja azokat egy tömbben. A tömb a maximális elemet tartalmazza, és megjelenik a képernyőn. Például: Írja be az 1. számot: 4 Írja be a 2. számot: 8 Adja meg a 3. számot: 9 Írja be a 4. számot: 2 Írja be az 5. számot: 4 Írja be a 6. számot: 5 Írja be a 7. számot: 0 Maximális szám: 9 Felhasznált anyag: Tömb deklarációk:<Имя>:Sor[<нач_зн> … <кон_зн>] nak,-nek<тип>; Tömb hozzáférés:<Имя массива> [ <Индекс>] RANDOM NUMBER GENERATOR (RNG) Véletlen számok generálásához a programban a következő operátorokat használjuk: Véletlenszerű – RNG inicializálás. Csak a program legelején deklarálják; Véletlenszerű – véletlen számot generál 0 és 1 között (valós típus); Véletlenszerű (N) - véletlen számot generál 0-tól N-1-ig (egész típusú); 53 TÖBBdimenziós tömbök 54 Intervallumok listája minden tömbdimenzióhoz (Név) : Tömb [ (kezdő_érték) .. (end_value) , (start_value) .. (end_value) , (etc) ] of (type) ; Példa egy 4 sorból és 6 oszlopból álló kétdimenziós tömb (mátrix, táblázat) deklarálására: Var A: Egész számok tömbje; Példa egy tömb kitöltésére: i:=1-től 4-ig do j:=1-től 6-ig tegye A := i+j; Ai , j 2 3 4 5 3 4 5 6 4 5 6 7 5 6 7 8 6 7 8 9 7 8 9 10 FELADAT Írjon programot, amely kitölt egy kétdimenziós tömböt -10 és 20 közötti véletlen számokkal, és kiírja az összeget a táblázat átlója mentén elhelyezkedő elemek közül . Felhasznált anyag: RNG inicializálás: Véletlenszerűvé tétel Véletlenszerű szám 0-tól N-1-ig: Véletlen (N) 55 FÁJLOK MŰKÖDÉSE FÁJLOKKAL 57 [e-mail védett]$ku⌂|"Hd9v*9(L*M=BYGRMxduB █ 8e*BOtCDrTVzHGJ1aBD>@B\(r8sE) █ :wcJvAmRa"v/.Wai;$`SWI=y2]suB █ ?LmB>cV^ .6b]o(QkВ8 █ cu<6`8Z":M^1;:8ANwak;,b2-4…u5 █ 2]suB?Hq>vF(LmBcAdz4wcP]o(QkВ █ 8c8df]e"v,su>+),VAEFБjFV,W$Q- █ y0G1GjN$-eБ|sqZ0`QnВ%\BD%y █ █ - sorlezáró fájl Létrehozás, olvasás, írás, bezárás FÁJLOKKAL végzett munka A műveletek sorrendje fájlokkal végzett munka során: 1. Fájlváltozó (FP) deklarálása 2. FP társítása fájlhoz 3. Fájl megnyitása olvasásra/írásra 4. Műveletek fájllal 5. A fájl bezárása (a fájl és az FP közötti kapcsolat is megszakad) 1. Az FP nyilatkozata<Имя>: Fájl<тип> ; <Имя>:szöveg; Varf: Szöveg; h: Egész szám fájlja; 2. Az FP társítása a hozzárendelés fájllal (<ФП>, <имя файла>); Hozzárendelés (f, 'c:\my\Data.ghm') 58 FÁJLOK MŰKÖDÉSE 3. Fájl megnyitása olvasáshoz/íráshoz Reset (<ФП>); - megnyitja a fájlt olvasáshoz Újraírás (<ФП>); - megnyitja a fájlt írásra 4. Műveletek a fájllal Read (<ФП>, <П1> , <П2>, …); - változókba olvas<П1>, <П2>stb. egy elem a mutató pozíciójában. Ír(<ФП> , <П1> , <П2>, …); - a változók értékeit beírja a fájlba<П1>, <П2>stb. egy elem a mutató pozíciójában. EoLn(<ФП>); - True értéket ad vissza, ha a karakterlánc végét elérték. EoF(<ФП>); - Igaz értéket ad vissza, ha a fájl végét elérte. 5. A fájl bezárása Close (<ФП>); 59 MUNKA FÁJLOKKAL Egyszerűsítse a programot, ha tudja, hogy a mátrix 5x5 (használja a For ciklust) 60 61. GYAKORLAT Írja meg a "DOM-3" programot. Az első fájl a névelős eset résztvevőinek nevét tartalmazza. A másodikban ugyanazok a nevek, de ragozásban. A harmadikban - az érzések kifejezéseinek listája vagy valamilyen cselekvés (szeret, nem szeret, csókol, harapni akar, szeret, tisztel, utál, látni akar, ölelés). A programnak véletlenszerűen információt kell vennie ezekből a fájlokból, és újat kell létrehoznia a következő elv szerint:<имя в им. пад> <чувство/действие> <имя в вин. пад>Olga szereti Sergeyt Oleg látni akarja, hogy Roman Katya tiszteli Nastyát stb. Felhasznált anyag: Operátorok neve: Hozzárendelés, Újraírás, Visszaállítás, Írás, Olvasás, Bezárás. GRAFIKA GRAFIKA A Pascal grafikával való munkához két fájlra van szükség – a graph.tpu modulra és az egavga.bgi grafikus adapter illesztőprogramjára. Az első a \UNITS könyvtárban, a második pedig a \BGI-ben található. ! egavga.bgi driver. Exe fájl futtatásakor kötelező! A rajzoláshoz: 1. csatlakoztassa a GRAPH modult (a Felhasználások részben); 2. inicializálja a grafikát (InitGraph); 3. lerajzol valamit; 4. zárja be a grafikus módot (CloseGraph) 63 GRAFIKA A grafikus mód inicializálása Rajzoljon egy vonalat. A toll a (0,0) ponttól a (639, 479) pontig tart. PROGRAM Primer_1; Graph, crt használata; VarGd,Gm: egész szám; BEGIN Gd:=0; InitGraph (Gd,Gm,'d:\BP\bgi"); Vonal (0,0,639,479); ReadKey; CloseGraph; END. 639 px. Koordinátarendszer 479 px. háromszög 2. Rajzoljon egy téglalapot a képernyő közepére a következővel: oldalak kétszer kisebbek, mint a képernyő megfelelő oldalai Felhasznált anyag: Grafikus modul: Grafikon Grafika inicializálása: InitGraph Grafikus mód lezárása: CloseGraph;GRAFIKA + COLOR SetColor(Szín: szó);Beállítja a toll színét GetColor: szó; Visszaadja a a toll színe SetBkColor(szín: szó); Beállítja a háttérszínt GetBkColor: szó; Visszaadja a háttérszínt Színek Fekete Kék Zöld Cián Piros Magenta Barna Világosszürke Sötétszürke Világoskék Világoszöld Világoscián Világospiros VilágosMagenta Sárga Fehér 66 - fekete - kék - zöld - cián – piros – lila – barna – világosszürke – sötétszürke – égszínkék – világoszöld – világos cián – rózsaszín – világos lila – sárga – fehér GRAFIKAI PRIMITIES Sor (x, y); Egy vonalat húz az aktuális tollkoordinátától az (x,y) koordinátákig. MoveTo(x, y); A tollat ​​(x,y) koordinátákra állítja. PutPixel(x, y, szín); Pontot rajzol koordinátákon (x,y) a színnel. GetPixel(x, y): szó; Az (x,y) koordinátákon lévő pont színét adja vissza. Téglalap(x1, y1, x2, y2); Megrajzolja egy téglalap körvonalát. Kör (x, y, r); Olyan kört rajzol, amelynek középpontja (x,y) és sugara r. SetLineStyle (Ln, 0, T) Megváltoztatja a körvonalak paramétereit. Ln - vonalstílus (0..3): 67 x1, y1 T - vonalvastagság: 1 = normál; 3 = vastag. FillEllipse(x, y, xr, yr); Rajzol egy kitöltött ellipszist, amelynek középpontja (x,y) Xr és Yr sugarakkal. SetFillStyle(Típus, Szín); Beállítja a zárt alakzatok típusát (0..11) és sraffozási színét ClearDevice; Tisztít grafikus képernyő festése az aktuális háttérszínre x2, y2 GRAFIKAI PRIMITÍVOK 68 69. FELADAT 1. Írjon programot, amely házat rajzol a monitor képernyőjére; 2. Írjon programot, amely csillagos eget rajzol a monitor képernyőjére véletlenszerű sugarú (1-5 pixel) és véletlenszerű elhelyezkedésű csillagokkal. A szín is véletlenszerű (fehér, világosszürke, sötétszürke); Felhasznált anyag: SetColor(Szín: szó); - Beállítja a rajz színét SetBkColor (szín: szó); - Beállítja az aktuális háttérszínt. line(x, y); - Egy vonalat húz az aktuális toll-koordinátától az (x,y) koordinátákig. MoveTo(x, y); - A tollat ​​(x,y) koordinátákra állítja. PutPixel(x, y, szín); - Színnel egy pontot rajzol koordinátákkal (x,y). Téglalap(x1, y1, x2, y2); - Téglalap körvonalat készít az aktuális színű vonalakból. Kör (x, y, r); - Olyan kört rajzol, amelynek középpontja (x,y) és r sugara. FillEllipse(x, y, xr, yr); - Rajzol egy kitöltött ellipszist, amelynek középpontja (x,y) Xr és Yr sugarakkal. GRAFIKA + ANIMÁCIÓ Szünet msec-ben. 70 ALPROGRAMOK ALPROGRAMOK Az alprogramok lehetővé teszik, hogy a kód ismétlődő részét külön töredékekre jelöljük ki, és illesszük be a programban a szükséges helyekre. A függvény az eljárástól eltérően a hívás eredményét adja vissza. Eljárások Funkciók Alprogramok: a kulcsszavak közé íródnak Begin End; nevekkel azonosítják, amelyeket az azonosítók megadására vonatkozó szabályok szerint írnak le; bemeneti és kimeneti paraméterei lehetnek; teljesen ismételje meg a fő program szerkezetét. 72 Program My; 1. szubrutin [1. szubrutin kód] 2. szubrutin [2. szubrutin kód] Begin 2. szubrutin 1. szubrutin Példa rendszerrutinokra: Write("OK"); ClrScr; Hossz(S); véletlen; // // // // eljárás egy paraméteres eljárással paraméterek nélkül funkció egy paraméteres funkcióval paraméterek nélkül 2. szubrutin vége. ALPROGRAMOK (SPR) Alprogramok egymásba ágyazása 1. program alprogram 3. alprogram 4. alprogram 2. alprogram. A DEP-ben leírt változók neve megegyezhet más DEP-ből származó változók nevével (ugyanaz a változó mindegyik DEP-ben deklarálható). A PPR-ben leírt változó neve védi az azonos nevű változókat az adott változót körülvevő PPR-től (ha a PPR1-ben és a PPR3-ban ugyanazok a változók vannak deklarálva, akkor ezek a változók minden PPR-ben egyediek lesznek). A programváltozókat globálisnak, az alprogramváltozókat pedig lokálisnak nevezzük. PARAMÉTEREK NÉLKÜLI ELJÁRÁSOK Rekord szintaxisa: Procedure (eljárás neve); (Változók, konstansok, típusok, címkék, modulok szakasza) Begin (Eljárás törzse); vége; Példa paraméterek nélküli eljárás használatára: 74 PARAMÉTEREK NÉLKÜLI ELJÁRÁSOK Példa azonos nevű menekülő változókra: Program Saját_program; crt-t használ; varA:string; // Eljárás leírása Eljárás My_Procedure; varA:string; Begin A:= "Subrutin"; WriteIn(A); vége; Begin A:= "Body"; WriteIn(A); az én_eljárásom; WriteIn(A); vége. // Eljáráshívás 75 ELJÁRÁSOK PARAMÉTEREKVEL 76 Az alprogramok univerzálisabbá tétele érdekében speciális mechanizmusokat alkalmaznak a program és alprogramjai közötti adatcserére. Rendszereljárások paraméterekkel: SetColor (piros); ( Eljárás téglalappal (0, 0, 639, 479); ( Eljárás InitGraph-al (Gd,Gm,'d:\BP\bgi");) ( Eljárás ( paraméterek egy paraméter ) több paraméterrel ) több különböző típussal ) ) Rögzítés szintaktikai eljárások paraméterekkel Eljárás (Név) ((Bemeneti változók területe) Var (Kimeneti változók területe (mindegyik változónak saját Var)))); Területek szerkezete: Változó_1, Változó_2, … : Típus; .. ......... ............. Változó_N-1, Változó_N, ... : Típus; Bármelyik régió hiányozhat ELJÁRÁSOK PARAMÉTEREKKEL Bemeneti paraméterek használata Rajzolási eljárás egy téglalap, amely a képernyőt határolja, megadott szín Nincs paraméter Paraméterekkel Eljárás kör; Kezdje SetColor (i); SetBkColor (b); Téglalap (0, 0, 639, 479); Vége; Procedure Cir (i, b: Integer); Kezdje SetColor (i); SetBkColor (b); Téglalap (0, 0, 639, 479); End; Eljárás hívása egy programban: Eljárás hívása egy programban: i:=6; b:=12; Cir; Cir (6, 12) 77 ELJÁRÁSOK PARAMÉTEREKKEL Eljárás kimeneti paramétereinek használata ra egy szög átváltása fokokból radiánba. PROGRAM EX_26_3; VAR x,a: valós; ELJÁRÁS Rad(alfa: valódi; var betta: valódi); (kimeneti változó) BEGIN Betta:= pi*alfa/180; VÉGE; BEGIN Write("Adja meg a szöget fokban: "); readln(x); Rad(x, a); (Eljáráshívás) Writeln("He egyenlő a szög radiánban = ",a:6:4); VÉGE. 78 79. FELADAT 1. Írjon egy eljárást háromszög rajzolására a következő formátumban: Háromszög (x1,y1, x2,y2, x3,y3, Szín) 2. Írjon egy eljárást egy téglalap területének kiszámítására az alábbiak szerint formátum: SRect (a, b, S), ahol, S az eljárás kimeneti paramétere. Felhasznált anyag: Procedure (Name) ((Input variable area) Var (Output variable area)); Területszerkezet: Változó_1, Változó_2, … : Típus; ............... ......... Változó_N-1, Változó_N, … : Típus; FUNKCIÓK 80 Függvény szintaxis Funkció ((Bemeneti változó területe) Var (Kimeneti változó területe)): (Típus) ; Eljárástervezés Funkciótervezés Eljárás S(a,b:real; var s:real); Kezdje s:= a+b; vége; Függvény Összeg(a,b: valós): valós; Kezdő összeg:= a+b; vége; Eljáráshívás Funkcióhívás S(10, 20, A); Írj egy); A:= S(10, 20); WriteLN(A); WriteLN (S(20, 30)); Csak akkor célszerű valamilyen szubrutint függvényként megtervezni, ha a munkájának valamilyen eredménye várható. Ha egy szubrutin csak egy bizonyos műveletsor végrehajtására koncentrál (megjelenítés, rajzolás stb.), akkor jobb, ha eljárásként írja meg. GYAKORLAT Írjon függvényt egy téglalap területének kiszámításához a következő formátumban: SRect (a, b) Felhasznált anyag: Funkció (Név) ((Bemeneti változó területe) Var (Kimeneti változó területe)): (Típus) ; Területszerkezet: Változó_1, Változó_2, … : Típus; ........................ Változó_N-1, Változó_N, … : Típus; 81 MODULOK MODULOK 83 Az egység (UNIT) egy független programegység, amelynek erőforrásait (eljárásokat és funkciókat) más programok használhatják. ProgramMy1; Modul1, Module2 ; __________________________ ______________________________ _____________________________________ ______________________ 1. MODUL 1. forráskészlet … My2 program; Modul1, Module2 ; __________________________ ______________________________ ____________________________________ ______________________ N MODUL Erőforráskészlet N A modulok a MODULOK HASZNÁLATA szakaszon keresztül csatlakoznak a programhoz. FELÉPÍTÉS 84 A modul a következő részekből áll: 1. Modul fejléce. 2. Interfész rész. (látható objektumok leírása) 3. Megvalósítási rész. (rejtett objektumok leírása) 4. Inicializálási rész (opcionális). Egység (Modul neve); Interfész ( Globális változók, konstansok, típusok szekciója) ( Modulok ) ( Eljárás- és függvényfejlécek listája ) Megvalósítás ( Lokális változók, konstansok, típusok szekciója) ( Eljárások és függvények megvalósítása ) Kezdete (Inicializálási rész ) Vége. ! A modul fejléc nevének meg kell egyeznie a modul fájl nevével! MODULOK Modul példa: Unit My_Unit; Interfész Varms: Array of Real; ( Globális tömb ) Funkció Cub(x:integer):Integer; ( Cub függvény = x^3 ) Függvény ext4(x:integer):Integer; ( Függvény ext4 = x^4 ) Megvalósítási függvény Cub(x:integer):Integer; ( A Cub függvény megvalósítása ) Begin Cub:= x*x*x; vége; Függvény Ext4(x:integer):Integer; ( Az ext4 függvény megvalósítása ) Begin Ext4:= x*x*x*x; vége; vége. 85 86. GYAKORLAT Írjon egy modult egy függvénnyel és egy eljárással: ( Függvényszámítás X1=1/x ) X1(a:real):real; ( Az S szó kinyomtatásának eljárása a képernyőn, az X pozícióban, Y WriteXY(S: String; X, Y: Iteger); Felhasznált anyag (modulstruktúra): Egység (Modul neve); Interfész ( Globális változók szekciója, konstansok, típusok) ( modulok ) ( Eljárások és függvényfejlécek listája ) Megvalósítás ( Lokális változók, konstansok, típusok szekciója) ( Eljárások és függvények megvalósítása ) Kezdete (Inicializálási rész ) Vége. )

Az óra témája: Programozási nyelv "PASCAL" A nyelv szövegszerkesztője.

Informatika tanár

GBOU Iskola No. 293 névadó. NÁL NÉL. Tvardovszkij, Moszkva

Bahtynova Natalia Valerievna


Az óra célja :

  • Megalkotni az első információkat a Pascal nyelvről; Ismerje meg a Pascal szövegszerkesztő használatát .

Történelmi információk a Pascal nyelvről

  • A Pascal programozási nyelv nevét a nagy francia matematikus és fizikus, Blaise Pascal tiszteletére kapta, aki 1642-ben. feltalált egy számológépet az aritmetikai műveletekhez, az úgynevezett "Pascal-kereket". 1968 végén Wirth professzor és munkatársai a zürichi Svájci Szövetségi Technológiai Intézetben kidolgozták a Pascal nyelv első változatát. Két évvel később - a fordító első verziója. 1971-ben Wirth leírást adott ki nyelvéről.

Blaise Pascal - francia matematikus, mechanikus, fizikus, író és filozófus


Pascal Wirth létrehozása két célt szolgált:

  • egyrészt a programozás, mint szisztematikus tudományág oktatására alkalmas nyelv kialakítása;
  • másodszor, a nyelv megvalósításának hatékonynak és megbízhatónak kell lennie.
  • A Pascal nyelv egyik előnye, hogy teljes mértékben megtestesíti a strukturált programozás gondolatát, aminek a lényege abban rejlik, hogy többféle konstrukció segítségével elvileg bármilyen algoritmus kifejezhető.

Niklaus Wirth (németül Niklaus Wirth, 1934. február 15.) svájci tudós, a programozási nyelvek fejlesztésének egyik leghíresebb teoretikusa. A Pascal, Modula-2, Oberon programozási nyelvek vezető fejlesztője és létrehozója.


Pascal elindítása

A Pascal nyelv futtatásához be kell töltenie a PASCAL.EXE fájlt, amely általában a PASCAL könyvtárban található.

Például: D:\PASCAL\PASCAL.EXE



  • Kék alapra írunk egy programot.
  • A tippvonalak szürke háttérre vannak írva.
  • A felső sorban a legördülő menük találhatók: F sziget, T szöveg, BAN BEN végrehajtás, NAK NEKösszeállítás, R módok, RÓL RŐL rögzítő, H megfigyelés.
  • A felső menü eléréséhez nyomja meg az F10 billentyűt. Az Alt billentyű és a felső menüben szereplő szavak első betűjének megnyomása kibontja az ablakot. (példa alt + B)

  • Program beírása a számítógépbe annyi, mint szöveg beírása a számítógépbe. Az alábbiakban felsoroljuk a leggyakrabban használt parancsokat. szöveg szerkesztő Turbo Pascal.

  • PgUp – egy oldallal feljebb;
  • PgDn - egy oldallal lefelé;
  • Home - a sor elejére;
  • End - a sor végéig;
  • Ctrl-PgUp - a szöveg elejére;
  • Ctrl-PgDn - a szöveg végére.

  • Backspace (←) - a kurzortól balra lévő karakter törlése;
  • Del - a kurzor által mutatott karakter törlése (a kurzortól jobbra);
  • Ctrl-Y - törölje azt a sort, amelyen a kurzor található;
  • Enter - beszúr egy új sort, vágja ki a régit;
  • Ctrl-Q L - az aktuális sor visszaállítása (akkor működik, ha a kurzor nem hagyta el a megváltozott sort).

  • Ctrl-K B - jelölje meg a blokk elejét;
  • Ctrl-K K - jelölje meg a blokk végét;
  • Ctrl-K Y - blokk törlése;
  • Ctrl-K C - blokk másolása;
  • Ctrl-K V - blokk mozgatása;
  • Ctrl-K W - írási blokk lemezfájlba;
  • Ctrl-K R - olvasási blokk a lemezfájlból;
  • Ctrl-K P - nyomtatási blokk;
  • Ctrl-K H - blokk kijelölés eltávolítása.

  • Melyik évben jelent meg a Pascal programozási nyelv első verziója?
  • Mik a Pascal nyelv előnyei?
  • Milyen gombokkal lehet kényelmesen mozgatni a kurzort a programban a képernyő bal felső sarkából a jobb alsó sarokba? (Mi van, ha fordítva?)
  • Mit kell tenni a program egy részének másolásához?
  • Vissza lehet állítani a program szövegében végzett változtatásokat?

Nikolaus Wirth De téves lenne azt gondolni, hogy a Pascal kizárólag tanulási nyelv. N. Wirth (1984) ezt mondta erről: „Az érvelés szerint a Pascalt tanítási nyelvként fejlesztették ki. Bár ez az állítás igaz, de nem az edzésben való felhasználása volt az egyetlen cél. Valójában nem hiszek annak sikerében, hogy a képzés során olyan eszközöket, technikákat alkalmazzunk, amelyek nem használhatók bizonyos gyakorlati problémák megoldására. ***


Pascal programozási nyelv Azóta a Pascal egyre népszerűbb, nem csak mint programozási alapelvek tanításának nyelve, hanem mint egy meglehetősen komplex alkotás eszköze is. szoftver. Eredeti formájában a Pascal meglehetősen korlátozott képességekkel rendelkezett, de ennek a nyelvnek a kiterjesztett változata, a Turbo Pascal egy erőteljes programozási nyelv.


Miért a PASCAL? A Pascal programozási nyelv Blaise Pascal francia tudósról kapta a nevét, aki 1642-ben feltalálta az első mechanikus számológépet. Ez egy kölcsönhatásban lévő fogaskerekek rendszere volt, amelyek mindegyike egy decimális szám egy számjegyének felelt meg, és 0-tól 9-ig tartalmazta a számokat. Amikor a kerék teljes fordulatot tett, a következő egy számjeggyel elmozdult. Pascal gépe egy összegző gép volt.


Alapvető információk a programozási nyelvekről A nyelv egy jelrendszer. A számítógépes nyelv (gépnyelv) bináris jelrendszer. Ezért ahhoz, hogy a számítógép megértsen egy írott programot, le kell fordítani egy nyelvre számítógép érthető. Ezt a fordítási folyamatot fordításnak nevezik.




Integrált környezet Turbo Pascal-7.0 A Pascal tömeges terjesztésében óriási szerepet játszott a Borland International. Sikerült létrehoznia a híres Turbo fejlesztői környezetet. Ez óriási előrelépés volt a programozási folyamat megkönnyítésében. Miért turbó? A turbó az angol szlengből fordítva gyorsulást jelent. A Turbo Pascal részét képező fordító nagyon gyorsan lefordítja a programot egy programozási nyelvről gépi kódokra.




A nyelv fő eszközei A nyelv szimbólumai a szövegkészítés során használt elemi jelek. Egy nyelv ábécéje ilyen szimbólumok halmaza. A Turbo Pascal 7.0 nyelvi ábécé tartalmazza: az összes latin nagy- és kisbetűt Arab számok(0 – 9) karakter + - * / =,. ; : _ () ( ) és egyéb segédszavak (fenntartott).


A Turbo Pascal 7.0 parancsok, függvénynevek, magyarázó kifejezések rögzítéséhez szigorúan meghatározott szavak halmaza található, amelyeket segédnek vagy fenntartottnak neveznek (ezek angol mnemonikus rövidítések). A szolgáltatásszavak három csoportra oszthatók: operátorok (READ, WRITELN stb.) függvénynevek (SIN, COS stb.) kulcsszavakat(VAR, BEGIN, END stb.) Alapvető nyelvi jellemzők


Egy érték neve a jelölése, ez egy betűből, számból és aláhúzásból álló szó, amely betűvel kezdődik. Számok: egész számok, valós: fixpont (-1,23; 654,2), lebegőpontos (2, 437,). Hat művelet: + összeadás, - kivonás, / osztás, * szorzás, mod a maradék keresése, div egész osztás.


A számtani kifejezést nevekből, számokból, aritmetikai műveletek előjeleiből, matematikai függvényekből építjük fel. A zárójelek a műveletek sorrendjének jelzésére szolgálnak. A négyzetre emeléshez az sqr(x) jelölést használjuk. A négyzetgyök kinyeréséhez az sqrt(x) jelölést használjuk. A modul jelölése abs(x).


Hozzárendelés operátor Változó neve:= aritmetikai kifejezés. x:= 3,24 vagy x:= x+4. Változótípus 1. Ha a bal oldali változó valós típusú, akkor az aritmetikai kifejezés lehet egész vagy valós típusú. 2. Ha a bal oldali változó egész típusú, akkor az aritmetikai kifejezés csak egész szám.


A program felépítése Pascal 1. részében - adatok és operátorok leírása. 2. rész - programblokk. Általános forma program: Program (programnév) címke (címkék listája) const (konstans értékek listája) típus (komplex adattípus deklarációk) var (program adatdeklarációk) begin (programblokk indítása) (algoritmus) end. (program vége)


Program neve: legfeljebb 8 karakter, betűvel kezdődik. ponttal végződik. A leíró rész 4 részből áll: címkék, konstansok, változók nevei és típusai. var változó neve és típusa: integer (integer), real (real). Például: var i, j: integer; x:real; Az egyes típusok leírása pontosvesszővel zárul. A programblokk operátorokat tartalmaz, amelyek leírják a probléma megoldásának algoritmusát.


Bemeneti és kimeneti utasítások: read (névlista) - leállítja a programot és megvárja, hogy a felhasználó beírja a számokat a billentyűzeten (szóközzel elválasztva), és megnyomja az ENTER billentyűt. Például: read(i, j); Az operátor működése után a kurzor az utolsó szám után helyezkedik el, de nem fordítódik le új sorra. Az adatok megadása után a kurzor új sorba helyezéséhez használja a readln(névlista) utasítást. írás (kimeneti lista) - Adatokat ír a képernyőre. Kimeneti lista - a számítási eredmények és a magyarázó szövegek vesszővel elválasztott nevei aposztrófokkal. Például: write(x=, x); Egy fixpontos szám jelenik meg a képernyőn. Például: write(x=, x:6:2); a képernyőn 6 számjegy jelenik meg, ezek közül kettő a tizedesvessző után (x =). A kurzort a writeln üres kimeneti operátor új sorba helyezi. readln üres bemeneti operátor






Turbo Pascal Alt + F10 - menü Fájl - Új - létrehozása új fájl Enter - minden sor végére kell tenni Ctrl + Y - sor törlése Enter - sor beszúrása A program végrehajtásához válassza a Futtatás menüpontot a Fordító menüben - lefordítja a programot Pascalból gépi nyelvre és megkeresi szintaktikai hibák. 1. Ha hibát talál, akkor a szerkesztő visszatér, a kurzor a hibára mutat. 2.Ha nem található hiba, a program lefut










Néha a THEN és az ELSE szavak után nem egy, hanem több utasítást kell végrehajtania. Ezután ezek a kezelők zárójelek között vannak. A nyitó zárójel a BEGIN szó, a záró zárójel az END szó. Az ELSE szó előtt nincs pontosvessző. Javasoljuk, hogy minden BEGIN - END pár egy oszlopba legyen írva. IF feltétel THEN kezdődik az 1. utasítás; operátor 2; utasítás N end ELSE begin utasítás 1; operátor 2; operátor M vége ;




Program E3; var a,b: egész szám; kezdje el az írást (írjon be két egész számot szóközzel elválasztva, majd nyomja meg); readln(a,b); ha a mod 2 = 0, akkor writeln (a páros) else writeln (a páratlan); ha b mod 2 = 0, akkor writeln (b - páros) else writeln (b - páratlan); readln end.


3 if a>0 6 if a 0 6 if a 0 6 if a 0 6 if a0 6 if a title="3 if a>0 6 if a


Program E31; var a, y: valódi; kezdje el az írást (adja meg a számot, majd nyomja meg); readln(a); ha a >0, akkor y:=3 különben y:=6; írás(y=,y); readln end. 0, akkor y:=3, különben y:=6; írás(y=,y); readln end."> 0 then y:=3 else y:=6; write (y=,y); readln end."> 0 then y:=3 else y:=6; write (y=,y); readln end." title="Program E31; var a, y: valódi; kezdje el az írást (adja meg a számot, majd nyomja meg); readln(a); ha a >0, akkor y:=3 különben y:=6; írás(y=,y); readln end."> title="Program E31; var a, y: valódi; kezdje el az írást (adja meg a számot, majd nyomja meg); readln(a); ha a >0, akkor y:=3 különben y:=6; írás(y=,y); readln end."> !}


A+b if a>b a*b if a b a*b if a b a*b if a b a*b if ab a*b if a title="a+b if a>b a* b if a


Program E32; var a,b,x: valós; kezdje el az írást (írjon be két számot szóközzel elválasztva, majd nyomja meg); readln(a); ha a >b, akkor x:=a+b különben x:=a*b; írás(x=,x); readln end. b akkor x:=a+b különben x:=a*b; írás(x=,x); readln end."> b then x:=a+b else x:=a*b; write (x=,x); readln end."> b then x:=a+b else x:=a*b; write (x=,x); readln end." title="Program E32; var a,b,x: valós; kezdje el az írást (írjon be két számot szóközzel elválasztva, majd nyomja meg); readln(a); ha a >b, akkor x:=a+b különben x:=a*b; írás(x=,x); readln end."> title="Program E32; var a,b,x: valós; kezdje el az írást (írjon be két számot szóközzel elválasztva, majd nyomja meg); readln(a); ha a >b, akkor x:=a+b különben x:=a*b; írás(x=,x); readln end."> !}




A ciklusok szervezése Az ismétlődő műveleteket a programozásban ciklusoknak nevezzük Feltétel nélküli ugrás operátor goto n, n egy egész szám (legfeljebb 4 karakter), egy címke. A címke 3-szor ismétlődik: 1. A Címke részben; 2.A goto utasításban; 3.A kezelő előtt, akihez feltétel nélküli ugrás történik.


Ciklusok szervezése feltételes és feltétel nélküli átmenetek operátorai segítségével. Feladat. Keresse meg az első húsz szám összegét! (1+2+3….+20). a ……………20 S ………….


Euklidész algoritmusa: minden alkalommal a nagyobb számot a kisebb értékével csökkentjük, amíg mindkét szám egyenlővé nem válik. Például: Kezdeti 1. lépés 2. lépés 3. lépés a= 25 b= gcd(a,b)=5


Program E5; var a, b: egész szám; írás megkezdése (gcd=,a); readln; vége. írás (Írjon be két természetes számot szóközzel elválasztva); readln(a,b); míg ab do if a>b then a:=a-b else b:=b-a; b majd a:=a-b else b:=b-a;"> b, majd a:=a-b else b:=b-a;"> b, majd a:=a-b else b:=b-a;" title="Program E5 ;var a, b: integer;begin write(gcd=,a);readln;end.write(Írjon be két természetes számot szóközzel elválasztva);readln(a,b);while ab do if a>b then a:= a-b else b:=b-a;"> title="Program E5; var a, b: egész szám; írás megkezdése (gcd=,a); readln; vége. írás (Írjon be két természetes számot szóközzel elválasztva); readln(a,b); míg ab do if a>b then a:=a-b else b:=b-a;"> !}




B, majd a:=a-b; if b>a akkor b:=b-a írás (Írjon be két pozitív egész számot szóközzel elválasztva); readln (a,b);" title="Program E6; var a, b: integer; írás kezdete (HOD=,a); readln; vége. ismételje meg a=b-ig; ha a>b, akkor a :=a-b, ha b>a, akkor b:=b-a írjon (Írjon be két természetes számot szóközzel elválasztva); readln (a,b);" class="link_thumb"> 40 !} Program E6; var a, b: egész szám; írás megkezdése (HOD=,a); readln; vége. ismételje addig, amíg a=b; ha a>b, akkor a:=a-b; if b>a akkor b:=b-a írás (Írjon be két pozitív egész számot szóközzel elválasztva); readln(a,b); b, akkor a:=a-b; if b>a akkor b:=b-a írás (Írjon be két pozitív egész számot szóközzel elválasztva); readln (a,b);"> b, akkor a:=a-b; ha b>a, akkor b:=b-a írjon (Írjon be két természetes számot szóközzel elválasztva); readln (a,b);"> b, akkor a:= a-b; if b>a akkor b:=b-a írás (Írjon be két pozitív egész számot szóközzel elválasztva); readln (a,b);" title="Program E6; var a, b: integer; írás kezdete (HOD=,a); readln; vége. ismételje meg a=b-ig; ha a>b, akkor a :=a-b, ha b>a, akkor b:=b-a írjon (Írjon be két természetes számot szóközzel elválasztva); readln (a,b);"> title="Program E6; var a, b: egész szám; írás megkezdése (HOD=,a); readln; vége. ismételje addig, amíg a=b; ha a>b, akkor a:=a-b; if b>a akkor b:=b-a írás (Írjon be két pozitív egész számot szóközzel elválasztva); readln(a,b);"> !}




dia 1

PROGRAMOZÁSI NYELV PASCAL Bogdanov Vladimir Ingyenes előadások http://prezentacija.biz/

3. dia

A Pascal nyelvet Niklaus Wirth alkotta meg 1968-1969-ben, miután részt vett az Algol-68 nyelvi standardfejlesztő bizottság munkájában. A nyelv Blaise Pascal francia matematikus, fizikus, író és filozófus nevéhez fűződik, aki megalkotta a világ első mechanikus gépét, amely két számot ad össze. Wirth első publikációja a nyelvről 1970-ben jelent meg, bemutatva a nyelvet, létrehozásának célját a szerző jelölte meg - egy kicsi és hatékony nyelv felépítését, amely strukturált programozás és strukturált adatok segítségével elősegíti a jó programozási stílust. Wirth ezt követő munkája egy Pascal alapú rendszerprogramozási nyelv megalkotására irányult, miközben megőrizte a lehetőségét egy szisztematikus, holisztikus professzionális programozási képzés lebonyolítására. A munka eredménye a Modula-2 nyelv.

4. dia

UCSD Pascal Fő cikk: UCSD Pascal 1978-ban a Kaliforniai Egyetemen (San Diego) fejlesztették ki az UCSD p-rendszert, amely magában foglalta a Pascal Wirth fordítójának portját a hordozható p-kódba, egy forráskód-szerkesztőbe, fájlrendszerés így tovább, valamint jelentős számú Pascal nyelvi kiterjesztés megvalósítása, például modulok, változó hosszúságú karakterláncok, fordítási direktívák, I/O hibakezelés, fájlok név szerinti elérése stb. Ezt követően a Pascal nyelv főbb megvalósításai erre a dialektusra épültek.

5. dia

Object Pascal] Főcikk: Object Pascal 1986-ban az Apple kifejlesztett egy objektumkiterjesztést a Pascal nyelvhez, amelynek eredménye az Object Pascal. Larry Tesler csoportja fejlesztette ki, aki Niklaus Wirth-tel konzultált.

6. dia

1983-ban jelent meg a Borland Turbo Pascal integrált fejlesztői környezetének első változata, amely az azonos nevű Pascal implementáción alapul. 1989-ben a Turbo Pascal 5.5-ös verziójához egy objektumnyelv-kiterjesztés került. legújabb verzió(7.0) átnevezték Borland Pascalra. Az objektumokat az Apple Object Pascal programjától kölcsönözték, és nagyon kevés nyelvi különbség van az Object Turbo Pascal 5.5 és az Apple Object Pascal között. A Borlanddal csaknem egy időben a Microsoft kiadta a Pascal objektum-orientált nyelv verzióját.] A Pascal ezen verzióját nem használták széles körben. A Borland Pascal implementációjának továbbfejlesztése nyomán született meg a Borland Object Pascal változata, később a Delphi programozási környezet fejlesztése során, amely ugyanezt a nevet kapta.

7. dia

A nyelv fejlődésének fontos lépése az l Pascal nyelv és a GNU Pascl ingyenes implementációinak megjelenése, amelyek nemcsak a nyelv sok más dialektusának jellemzőit szívták magukba, hanem a benne írt programok rendkívül széles körű hordozhatóságát is biztosították ( például a GNU Pascal több mint 20-at támogat különféle platformok, több mint 10 különböző operációs rendszer, A Free Pascal speciális kompatibilitási módokat biztosít a nyelv különféle gyakori dialektusaival, mint például a Turbo Pascal (teljes kompatibilitás), a Delphi és mások). A Delphi 2003 óta egy nyelvi megvalósítás készült a Net platformhoz, bár a fejlesztők továbbra is a Delphi korábbi verzióit használják. A Free Pascal, GNU Pascal és TMT Pascal kereskedelmi fejlesztéseiről itt Ebben a pillanatban keveset tudunk. Emellett a Southern Federal University kifejlesztette a PascalABC.NET-et, a Pascal programozási nyelvet, amely a Delphi nyelv legtöbb funkcióját tartalmazza, valamint számos saját bővítményt. A Microsoft.NT platformra épül, és szinte minden modern nyelvi funkciót tartalmaz: osztályok, operátor túlterhelés, interfészek, kivételkezelés, általános osztályok és szubrutinok, szemétgyűjtés, lambda kifejezések.

8. dia

A nyelv jellemzői a szigorú gépelés és a strukturális (eljárási) programozási eszközök elérhetősége. A Pascal volt az egyik első ilyen nyelv. Wirth szerint a nyelvnek hozzá kell járulnia a fegyelmezett programozáshoz, ezért az erős gépelés mellett minimálisra csökkentik az esetleges szintaktikai kétértelműségeket a Pascalban, és magát a szintaxist a szerző igyekezett már a nyelvvel való első ismerkedéskor is intuitívvá tenni.

9. dia

Ennek ellenére a nyelvnek kezdetben számos korlátja volt: a változó hosszúságú tömbök függvényeknek való átadásának lehetetlensége, a dinamikus memóriával való munkavégzéshez szükséges normál eszközök hiánya, korlátozott I / O könyvtár, a más nyelveken írt függvények összekapcsolására szolgáló eszközök hiánya. nyelvek, külön fordítóeszközök hiánya stb. Az akkori Pascal nyelv hiányosságainak részletes elemzését Brian Kernighan végezte el a „Miért nem Pascal a kedvenc programozási nyelvem” című cikkében (ez a cikk a korai Az 1980-as évek, amikor a Pascal leszármazottja, a Modula-2 nyelv megszabadult a legtöbb rossztól, és Pascal fejlettebb dialektusaitól is. A Pascal egyes hiányosságait az 1982-es ISO szabvány javította, különösen a nyílt tömbök jelentek meg a nyelvben, amelyek lehetővé tették ugyanazokat az eljárásokat a különböző méretű egydimenziós tömbök feldolgozásához.

10. dia

A nyelv sok hiányossága azonban nem jelenik meg, sőt előnyökké válik a programozás megtanulásakor. Ráadásul az 1970-es évek tudományos környezetének fő programozási nyelvéhez képest (ami a Fortran volt, amelynek sokkal jelentősebb hátrányai voltak), a Pascal jelentős előrelépést jelentett. Az 1980-as évekre a Pascal számos alapja lett tanterveket, bizonyos esetekben speciális oktatási programozási nyelveket hoztak létre ennek alapján, például az 1980-as évek elején a Szovjetunióban, hogy megtanítsák az iskolásoknak a számítástechnika alapjait és Számítástechnika Andrey Ershov kifejlesztett egy Algolo-Pascal-szerű "tanulási algoritmikus nyelvet".

dia 11

A nyelv széleskörű elterjedését és fejlesztését biztosító Pascal leghíresebb megvalósítása a Borland Turbo Pascal, amely aztán Pascal objektummá nőtte ki magát DOS-ra (5.5-től kezdve) és Windows-ra, majd Delphi-vé, amelyben a nyelv jelentős kiterjesztései. nyelvet vezették be. A Turbo Pascal for DOS és a Delphi for Windows programban használt Pascal dialektusok más sikeres kereskedelmi megvalósítások hiánya miatt váltak népszerűvé.

dia 12

Miután 1970-ben megkezdődött a Pascal használata, és megjelentek a nem csak kiegészítésekben, hanem szintaxisban is eltérő implementációk, felvetődött a nyelv szabványosításának kérdése. A nyelvi szabványt Niklaus Wirth dolgozta ki 1974-ben Kathleen Jensennel. Később átvették az ISO nemzetközi szabványát és az ANSI amerikai szabványát. Jelenleg három alapvetően eltérő szabvány létezik: Unextended Pascal (eredeti), Extended Pascal (bővített), Object-Oriented Extensions to Pascal (objektumorientált Pascal kiterjesztés).

dia 13

dia 14

Szintaxis és nyelvi konstrukciók A Pascal eredeti formájában tisztán procedurális nyelv, és számos Algol-szerű szerkezetet és konstrukciót tartalmaz fenntartott szavakkal, mint például if, then, else, while, for stb. A Pascal azonban nagyszámú nyelvet is tartalmaz. olyan információk és absztrakciók strukturálására szolgáló funkciók, amelyek nem voltak jelen az eredeti Algol-60-ban, például típusdefiníciók, rekordok, mutatók, felsorolások és halmazok. Ezeket a konstrukciókat részben a Simula-67, Algol-64 nyelvekből örökölték vagy ihlették, amelyeket Niklaus Wirth AlgolW (angol) orosz készített. és Hoare javasolta. A modern dialektusokban (Free Pascal) elérhetők olyan műveletek, mint az operátor és a funkció túlterhelése.

dia 15

program p; kezdés vége. A program nem csinál semmit, és üres utasításblokkot tartalmaz. Példa egy olyan programra, amely kiírja a "Hello, world!" karakterláncot:

16. dia

begin writeln("Helló, Világ!"); ( sor kimeneti operátor ) vége.

dia 17

dia 18

19. dia

20. dia

Pascalban a bitenkénti műveletek megengedettek egész típusokon (byte, shortint, word, integer, longint és ezek tartományai). Logikai műveletek biteken: A korábban tárgyalt logikai műveletek két egész operandus bitjein hajthatók végre: not, és, or, xor. A bitenkénti és a logikai műveletek közötti különbség az, hogy a bitenkénti (bitenkénti) műveleteket az operandusok egyes bitjein hajtják végre, és nem a decimális (általában) ábrázolásbeli értékükön. Megkülönböztetik az ordinális adattípusok (sorrend) fogalmát, ezek közé tartoznak az egész típusú (előjeles és előjel nélküli), a logikai (logikai), a karakteres (char), a felsorolt ​​típusok és a tartománytípusok. Az ordinális típusokat egész számmal (kóddal) adjuk meg, amelyet az ord függvény segítségével kaphatunk meg. Az ordinális típusokon végrehajtott összes művelet a kódjaikon történik.

dia 21

dia 22

Sorrendi típusoknál az inc, dec, succ, pred, ord, összehasonlító műveletek (=>

dia 23

dia 24

dia 25

Jensen és Wirth Pascaljában a karakterláncokat karaktertömbökként ábrázolták; ezért fix hosszúságúak voltak, és általában erre a hosszra párnázták ki szóközökkel. A modern Pascalban a karakterláncokkal való munkához a beépített karakterláncot használják, amely támogatja az összefűzést (+) és az összehasonlítást (> =

26. dia

Az 1970-1990-es évek nyelvének dialektusaiban az [n] típusú karakterláncot vagy egyszerűen stringet a char karakterek tömbjeként határozták meg (az n alapértelmezés szerint 80 az UCSD Pascalban és 255 a Turbo/Borland Pascalban), a null karakter. kód ebben az ábrázolásban a karakterlánc hosszának beállítására szolgál, illetve a karakterláncnak lehet maximális méret 255 karakter. Alapértelmezés szerint a Delphiben és a FreePascalban az AnsiString típust használják Stringként, amelynek memóriáját a fordító dinamikusan lefoglalja és felszabadítja, a maximális karakterláncméret pedig a jelenlegi implementációkban 2 gigabájt. Ezenkívül a Delphiben és a Free Pascalban a WideString típus használható sztringként, ahol a karakterek 16 bites UCS-2 kódolású reprezentációját használják, miközben nincs lehetőség egybájtos karakterláncokból többbájtos karakterláncokká konvertálni. és fordítva a nyelv szabványos könyvtárában.

dia 27

Új típusok definiálhatók a meglévőkből: típus (típusdeklarációs rész) x = Integer; y=x;

dia 28

Sőt, primitív típusokból összetett típusok is összeállíthatók: type ( típusdeklarációs szakasz ) a = Integer tömb; ( tömbdefiníció ) b = rekord ( rekord definíció ) x: Integer; y: Char; vége; c = a fájl; (fájl definíció)

29. dia

A Pascal fájltípusai gépelt, szöveges és típus nélküli fájlokra vannak osztva. Amint a fenti példában látható, a Pascalban beírt fájlok azonos típusú elemek sorozatai. Minden fájlhoz tartozik egy puffermutató változó, amelyet f^ jelöl. A get (olvasáshoz) és put (íráshoz) eljárások a mutatót a következő elemre mozgatják. Az olvasás úgy van megvalósítva, hogy az read(f, x) ugyanaz, mint a get(f); x:=f^. Ennek megfelelően az írást úgy valósítjuk meg, hogy a write(f, x) ugyanaz, mint az f^ := x; put(f). Szöveg szöveges fájlok A char típusú fájl kiterjesztéseként vannak definiálva, és a beírt fájlokon végzett szabványos műveleteken (karakter olvasása, írása) mellett lehetővé teszik a karakterek bevitelét / kimenetét minden adattípusú fájlba, hasonlóan a konzol bemenetéhez / kimenetéhez.

30. dia

A típus nélküli fájlok a fájl típusú változókként vannak deklarálva. Ezekkel egy pufferen keresztül több, meghatározott hosszúságú bájt blokkhoz bájtról bájtra íratlan I / O műveleteket lehet végrehajtani, ehhez speciális blokkolvasási és blokkírási eljárásokat (UCSD kiterjesztést) használnak.

dia 31

32. dia

dia 33

34. dia

35. dia

Mutatók A Pascal támogatja a mutatók használatát (beírt ^type és típus nélküli mutató): type a = ^b; b = x rekord: egész szám; y: Char; z:a; vége; var pointer_to_b:a;

36. dia

Itt a pointer_to_b változó egy mutató a b adattípusra, amely egy rekord. A beírt mutató típusát a hivatkozott típus deklarációja előtt lehet megadni. Ez egy kivétel a szabály alól, hogy bármit deklarálni kell, mielőtt felhasználható lenne. Ennek a kivételnek a bevezetése lehetővé tette az adatstruktúrák ismétlődő definícióinak megszervezését, beleértve a lineáris listákat, veremeket és sorokat, beleértve a bejegyzésre mutató mutatót a bejegyzés leírásában (lásd még: null pointer - nil). A beírt mutatónak van hivatkozási művelete (szintaxisa: pointer^). Készíteni új rekordés rendelje hozzá a 10 értéket és az A karaktert az x és y mezőkhöz, akkor a következő utasítások szükségesek:

37. dia

new(pointer_to_b); ( mutató kiosztása ) pointer_to_b^.x:= 10; ( mutatóhivatkozás és rekordmező hozzáférés ) pointer_to_b^.y:= "A"; pointer_to_b^.z:= nulla; ... dispose(pointer_to_b); (memória felszabadítása a mutató alól)

38. dia

Használhatja a with utasítást rekordok és objektumok mezőire való hivatkozáshoz is, ahogy a példában is látható: new(pointer_to_b); a pointer_to_b^-vel kezdje x:= 10; y:= "A"; z:= null vége; ... dispose(pointer_to_b);

39. dia

Procedurális típus Pascal Jensen és Wirth eredeti nyelvében az eljárási típust csak formális paraméter leírásánál használták. Már a TP-ben is létezett teljes eljárási típus. A típusdeklaráció egy eljárás vagy függvény fejlécét tartalmazza (név nélkül), amely általában leírja az alprogram felületét. Az ilyen típusú érték egy mutatót tartalmaz egy alprogramra, amelynek címe megfelel a típusdeklarációban megadottnak. Egy változó azonosító használható a megfelelő eljárás vagy függvény meghívására.

40. dia

A Pascal egy strukturált programozási nyelv, ami azt jelenti, hogy egy program egyedi szabványos utasításokból áll, amelyek szekvenciálisan futnak le, ideális esetben a GOTO parancs használata nélkül.

41. dia

A while, if, case utasításokhoz egy blokk használható végrehajtott utasításként. Az ilyen konstrukciót, amely egy közönséges utasítás vagy blokk, összetett utasításnak nevezzük. A Turbo Pascalban a fordítási folyamat vezérléséhez vannak olyan direktívák, amelyek megjegyzésekben vannak elhelyezve, és lehetővé teszik a fordító működési módjának váltását - például az I / O műveletek ellenőrzésének engedélyezését és letiltását, a túlcsordulást:

42. dia

A Pascalban az alprogramokat eljárásokra és függvényekre osztják: Szintaktikailag az eljárások és függvények egy fejlécből állnak (amely tartalmazza a kulcsszó eljárást vagy függvényt, egy nevet, amelyet zárójelben követhet az átadandó paraméterek leírása, egy visszatérési típus, függvények esetén kettősponttal, eljárások esetén pontosvesszővel elválasztva), a fejlécet a törzs követi, majd a ; karakter.

43. dia

Az eljárások törzse, akárcsak a program, tartalmazhat eljárások és funkciók leírását. Így az eljárások és a függvények tetszőleges mélyen beágyazhatók egymásba, miközben a programtörzs a legfelső helyen áll a láncban. Ezen túlmenően az eljárás/funkció leírása előtt található változók, típusok, konstansok, külső törzsek (eljárások, függvények, programok) leírása részeinek tartalma elérhető benne. Ezenkívül a legtöbb nyelvjárásban egy eljárásból hozzáférhet egy külső eljárás paramétereihez. Az eljárások/függvények címsora után a törzs helyett a forward kulcsszó helyezhető el, ez akkor történik meg, ha az eljárás/függvény leírása a meghívása után a programban található, és a program összeállításának lehetőségéhez kapcsolódik. Pascalban támogatott egy menetben. Az eljárások abban különböznek a függvényektől, hogy a függvények értéket adnak vissza, míg az eljárások nem.

44. dia

A csatlakoztatott modulok megjelenése előtt modern forma a Pascal által támogatott modularitás egyes megvalósításai a fejlécfájlok beillesztésének mechanizmusa miatt, hasonlóan a C nyelvben található #include mechanizmushoz: például egy pszeudo megjegyzésként formázott speciális direktíva ($INCLUDE "fájl") segítségével a tartalom a megadott fájl eredeti szöveges formában közvetlenül szerepelt a program szövegében. Így lehetett osztani programozási kód sok töredékre, a szerkesztés megkönnyítése érdekében, de a fordítás előtt automatikusan egy programfájlba egyesültek, amit végül a fordító dolgozott fel. A modularitásnak ez a megvalósítása primitív, és sok nyilvánvaló hibája van, ezért gyorsan kicserélték. Modern Pascal implementációk (az UCSD Pascal-tól kezdve) támogatja a modulokat. A programmodulok kétféleek lehetnek: a fő programmodul, amely szokás szerint a program kulcsszóval kezdődik, és amelynek törzse a program memóriába való betöltése után lefutott kódot tartalmazza, valamint a típusokat, konstansokat, változókat, eljárásokat tartalmazó segédmodulok. és más modulokban való használatra szánt funkciók, beleértve a fő modult is.

45. dia

Általános szerkezet a Pascal beépülő modulja így néz ki: unit UnitName1; interfész ... implementáció ... begin (elhagyható - akkor használatos, ha inicializálási utasításokat kell elhelyezni) ... end.

46. ​​dia

Egy másik lehetőség is lehetséges: unit UnitName2; interfész ... megvalósítás ... inicializálás ... véglegesítés .... vége.

47. dia

A főprogramtól eltérően az egységfájl a UNIT kulcsszóval kezdődik, amelyet az egység neve és egy pontosvessző követ. A modern megvalósítások általában megkövetelik, hogy a modulnév megegyezzen a fájlnévvel forráskód Ez a modul tartalmazza. Egy modul három részből áll: egy interfész szakaszból, egy megvalósítási szakaszból és egy modul törzsből.

48. dia

Az interfész szakasz az első, az INTERFACE kulcsszóval kezdődik, és a modul azon pontján ér véget, ahol az implementációs szakasz vagy törzs kezdődik. Az interfész szekció deklarálja azokat az objektumokat (típusok, konstansok, változók, eljárások és függvények - fejlécek vannak elhelyezve), amelyeknek a modulon kívülről elérhetőnek kell lenniük. Ebben az esetben megengedett a típusok részleges deklarálása: struktúra megadása nélkül, csak egy névvel deklarálhatók. Ha ezt a típust külső programban használjuk, megengedett az ilyen típusú változók és paraméterek deklarálása, értékek hozzárendelése, de a megvalósítás részleteihez nem lehet hozzáférni. Az interfész szekció eljárásai és függvényei előremenőként vannak deklarálva - fejlécek paraméterekkel, de törzs nélkül. A modul interfész szakaszának összetétele olyan, hogy elegendő kódot generálni, amely ezt a modult használja. Az interfész részben deklarált változók globálisak, azaz egyetlen példányban léteznek, és a program minden olyan részében elérhetők, amely ezt a modult használja.

49. dia

Az implementáció szakasz az interfész szakaszt követi, és az MEGVALÓSÍTÁS kulcsszóval kezdődik. Tartalmazza az interfész részben deklarált eljárások és függvények leírását, valamint az interfész eljárások és funkciók megvalósításához szükséges típusok, konstansok, változók, eljárások és függvények leírását. Az interfész szakaszban deklarált eljárás vagy funkció leírásának pontosan ugyanazzal a fejléccel kell rendelkeznie, mint a deklarációban. A törzs használhatja a modul egyéb eljárásait és funkcióit, mind az interfész részben, mind a megvalósítási szakaszban deklarálva. Az implementációs részben deklarált változók valójában globálisak (azaz minden ilyen változónak csak egy példánya van a teljes programban), de csak a jelen modul megvalósítási részében leírt eljárásokból és függvényekből érhetők el, valamint a testéből. Ha az interfész szakaszban vannak rövidített típusdeklarációk, akkor ezeket a típusokat teljes mértékben deklarálni kell az implementációs részben.

50. dia

A modul törzse a következővel kezdődik: felső szint egymásba ágyazás a BEGIN kulcsszóval. A törzs tartalmaz egy programkódot, amely a modul betöltésekor egyszer lefut. A törzs használható inicializálásra, kezdeti értékek hozzárendelésére a modulváltozókhoz, erőforrások hozzárendelésére a működéséhez stb. Lehet, hogy hiányzik a modul törzse. Számos Pascal-megvalósításban, például a Delphiben, a modul törzse helyett két szakasz (szintén opcionális) használható - INICIALIZÁCIÓ és VÉGLEGESÍTÉS. A modul végére kerülnek, a megfelelő kulcsszó után. Az első, az inicializálási rész azt a kódot tartalmazza, amelyet a modul betöltésekor végre kell hajtani, a második, a véglegesítési szakasz pedig azt a kódot tartalmazza, amely a modul kirakodásakor kerül végrehajtásra. A véglegesítési szakasz az inicializáláshoz képest fordított műveleteket hajthat végre – objektumok eltávolítása a memóriából, fájlok bezárása, lefoglalt erőforrások felszabadítása. A modul az END kulcsszóval, majd egy ponttal végződik.

51. dia

Egy modul használatához a főprogramnak vagy egy másik modulnak importálnia kell a modult, azaz tartalmaznia kell egy nyilatkozatot a használatáról. Ez a deklaráció egy modul include utasítással történik, amely a USES kulcsszó, amelyet a beillesztendő modulok vesszővel elválasztott neve követ. A kapcsolódási utasításnak közvetlenül a program fejlécet kell követnie, vagy az INTERFACE kulcsszó után, ha a csatlakozás modulban történik.

52. dia

Az interfész szekcióba kapcsolt modulok a teljes modulban használhatók - mind az implementációs részben, mind a törzsben. De az implementációs szakasznak lehet saját include utasítása (az IMPLEMENTATION kulcsszót követi), amely tartalmazza azon beépülő modulok nevét, amelyek nincsenek az interfész szakaszban, de az implementációs szakaszhoz szükségesek. Az egyik oka annak, hogy külön csatlakozási listát használjunk a megvalósítási szakaszhoz, ha két vagy több modul használja egymást. Az ilyen modulok használatáról szóló nyilatkozatokban a körkörös hivatkozások elkerülése érdekében legalább az egyiknek tartalmaznia kell a másikat a megvalósítási szakaszban.

53. dia

A modulok interfész szakaszaiban deklarált bármely objektum használható abban a programban, amelyhez ezek a modulok csatlakoztatva vannak. A beépülő modulokból importált objektumok neve változatlan marad, és közvetlenül használhatók. Ha két vagy több csatlakoztatott modulnak azonos nevű objektuma van, és a fordító nem tud különbséget tenni közöttük, akkor egy ilyen objektum használatának kísérlete fordítási hibát generál – kétértelmű névmeghatározást. Ebben az esetben a programozónak névminősítést kell kérnie - adja meg a nevet "." formátumban.

54. dia

Problémák adódhatnak, ha két különböző, azonos nevű modult kell használni a programban. Ha a modulok csak lefordított formában érhetők el (vagyis a nevüket nem lehet megváltoztatni), akkor lehetetlen egyidejűleg importálni őket. Nyelvi szinten nincs szabványos megoldás egy ilyen ütközésre, de adott fordítóprogramok kínálhatnak ilyen vagy olyan módot annak megkerülésére, különösen az importált modulokhoz álnevek hozzárendelését, és közvetlenül meghatározva, hogy melyik modult melyik fájlból kell átvenni.

55. dia

A modulok külön fordításra készültek – a fordítónak nem kell importált modulokat fordítania ahhoz, hogy le tudja fordítani az azokat használó modult. A modul helyes fordításához azonban a fordítónak hozzá kell férnie az összes használt modul interfész részéhez. Két különböző, néha kombinált megközelítés létezik az ilyen hozzáférés megszervezésére. A modulokat speciális formátumú bináris fájlokba fordítják (minden fordítónak megvan a sajátja), amelyben a részletes információk Az interfész szekcióban deklarált objektumokról a modul lefordításakor létrehozott objektumnyelvet is tartalmazhatja, de csak a modul interfész részét használja. Ha egy könyvtári modult lefordított formában (teljes forrásszöveg nélkül) adunk meg, akkor a bináris fájl mellett a modul forráskódjának csonka fájlja is található, amely csak az interfész részt tartalmazza. Ez elegendő ahhoz, hogy a fordító megfelelően feldolgozza a használó modulokból érkező hívásokat, és a program fordításának szakaszában a linker egyszerűen belefoglalja a bináris fájlt a programba.

56. dia

Modulok be- és kirakodása Ahhoz, hogy a modul megfelelően működjön, előfordulhat, hogy a használat megkezdése előtt végre kell hajtania néhány műveletet: inicializálja a változókat, nyissa meg a szükséges fájlokat, lefoglalja a memóriát vagy más erőforrásokat. Mindez megtehető a modul törzsében, vagy az inicializálási részben. Az inicializálás fordítottja a véglegesítés szakaszban történik.

57. dia

A modulok inicializálásának és véglegesítésének sorrendjét közvetetten a felhasználások részben a deklaráció sorrendje határozza meg, de statikusan lefordított programok esetében (ahol a modul vagy egy futtatható fájlba van fordítva a főprogrammal, vagy egy különálló dinamikus könyvtárban található, de a kezdeti betöltési szakaszban betöltve), a fordító mindig garantálja, hogy az inicializálás megtörténik a modul első használata előtt. A véglegesítés akkor történik meg, amikor a program leáll, a fő modul leállása után, így a használt modulok később kerülnek véglegesítésre, mint az azokat használók.

58. dia

A saját programozó által vezérelt modulok dinamikus betöltése esetén az inicializálók a betöltéskor futnak le, vagyis abban a pillanatban, amikor a modulbetöltési parancs visszaadta a vezérlést, az inicializálója már végrehajtásra került. A véglegesítő a kirakodás után kerül végrehajtásra, általában akkor, amikor a modul kirakási parancsát végrehajtják. Ha ezt a parancsot nem hívják meg, a dinamikusan betöltött modulok ugyanúgy véglegesítésre kerülnek, mint az összes többi - a program befejezésekor.

59. dia

Az objektum-orientált programozás (OOP) összetett szoftverek létrehozására szolgáló technológia, amely egy program objektumok halmazaként való ábrázolásán alapul, amelyek mindegyike egy bizonyos osztály példánya, és az osztályok egy hierarchiát alkotnak a tulajdonságok öröklődésével.

60. dia

Az OOP fő előnye a modulok közötti hívások számának és a modulok között továbbított információ mennyiségének csökkenése. Ez az adatok teljesebb lokalizációjával és a feldolgozási rutinokkal való integrációjával érhető el.

61. dia

Az OOP fő hátrányai a szoftverrendszer bonyolultabb szervezése miatti teljesítménycsökkenés, valamint általában a bináris kód mennyiségének észrevehető növekedése (különösen, ha szabványos osztálykönyvtárakat használnak kis programokban) arra a tényre, hogy a legtöbb modern fordító és linker nem képes azonosítani és eltávolítani minden olyan kódot, amely nem használt osztályokba, virtuális metódusokba és egyéb OOP elemekbe esik.

62. dia

Az Object Pascalban az osztályok a használatával vannak meghatározva objektumtípus, hasonlóan a rekordhoz, amely az adatmezők mellett eljárás- és függvényfejléceket is tartalmazhat (ezeket metódusoknak nevezzük). A leírt metódusok neve követi az osztály nevét, ponttal elválasztva.

63. dia

A konstruktor és a destruktor normál eljárásként van megadva, de az eljárásazonosító helyett a konstruktor és a destruktor kulcsszavak vannak megadva. Ennek megfelelően a C++-szerű nyelvektől eltérően az osztálynévtől eltérő nevük van, több destruktor is lehet, és lehetnek paramétereik (a gyakorlatban ezt a szolgáltatást ritkán használják, általában egy osztálynak egyetlen Destroy destruktora van, amely felülírja a virtuális a szülő osztály destruktora ).

64. dia

Egyszeri öröklődés, osztálypolimorfizmus, virtuális metódusmechanizmus támogatott (a virtual szó az osztálymetódus fejléce után). Léteznek dinamikus módszerek is (a TP-ben úgy írják le, hogy a virtual szó után egész számot adnak hozzá, és főleg üzenetfeldolgozásra használják; a Delphiben és a FreePascalban az üzenet szót használják erre a célra, a dinamikus szót pedig a közönséges létrehozására. dinamikus módszerek), amelyek kevesebb memóriahasználatban és kisebb hívási sebességben különböznek az ősök dinamikus metódusainak megkettőzésének hiánya miatt a gyermek VMT-jében (a FreePascal azonban nem tesz különbséget a virtuális és a dinamikus módszerek között). A Delphiben az FPC a műveletek, absztrakt metódusok, privát, védett, nyilvános, közzétett direktívák túlterhelését valósította meg (alapértelmezés szerint az osztálytagok nyilvánosak):

65. dia

A Delphi dialektusban osztályok is létrehozhatók a class szó használatával (sőt, az objektumosztályokkal való kölcsönös öröklődés nem megengedett), és bevezetik az interfészt (interfész) - minden metódus absztrakt, és nem tartalmazhat adatmezőket. Minden osztály (az osztállyal létrehozott) a TObject-ből öröklődik, az összes interfész az IUnknown-ból származik. Az osztállyal létrehozott osztályok több interfészt is megvalósíthatnak.

66. dia

A Delphiben interfészeket vezettek be a Microsoft COM technológiájának támogatására. Az osztályoknak (Class) a közönséges osztályokkal (Object) ellentétben nincs szükségük kifejezett memóriafoglalásra/felszabadításra, a memóriát a Create nevű konstruktor dinamikusan lefoglalja, az osztálynévvel hívja meg, és felszabadítja, ha egy Destroy nevű destruktort hívnak (ezek lehet más neve is). Egy ilyen osztály változója az objektumosztálytól eltérően egy osztálypéldány címét tárolja a memóriában, a nulla érték az üres hivatkozás jelzésére szolgál, ezért egy objektum felszabadításához egy speciális szabad metódus van definiálva a TObject-ben, amely ellenőrzi a nullára való hivatkozást, és meghívja a Destroy virtuális destruktort. Az ilyen osztályokat használó kód így néz ki:

67. dia

1 csúszda

„ISMERKEDÉS A PASCAL NYELVEL” ÓRA A TÉMÁBAN: Matematika és számítástechnika tanár, MBO USOSh No. 2, Kalach-on-Don, Volgograd region Anisimova N.A.

2 csúszda

AZ ÓRA CÉLJA: a Turbo Pascal nyelv program felépítésének, operátorainak, formázási szabályainak és írásjeleinek megismerése.

3 csúszda

TURBO PASCAL programozó rendszer. A Pascal egy univerzális programozási nyelv, amely sokféle információfeldolgozási probléma megoldását teszi lehetővé.

4 csúszda

1) Turbo Pascal programozási nyelv; 2) integrált programozási környezet (fordító: gépi kódra fordítja a programot és értelmező: parancsokat hajt végre) A TR PROGRAMOZÓ RENDSZER ÖSSZETÉTELE:

5 csúszda

1) latin betűk - nagy és kicsi; 2) az orosz ábécé betűi - kicsi és nagy; 3) számok - 0-tól 9-ig; 4) a műveletek jelei - +, -, /, *, =, =; 5) elválasztó karakterek - () ( ) ; . , ‘ _% & # stb. TURBO PASCAL programozási nyelv ábécé

6 csúszda

7 csúszda

Programfejléc Változó deklarációs szakasz Nyilatkozat szakasz (főtörzs)

8 csúszda

A változódeklaráció szakasz a Var szóval kezdődik, amelyet az azonos típusú változónevek vesszővel elválasztott listája követ. A Pascalban kétféle szám létezik: valós és egész. A változónevek latin betűkből és számokból állnak, az első karakter egy betű. Azonos típusú változók VAR listája: INTEGER; hasonló változók listája:REAL;

9 csúszda

Az operátori rész a program fő része. Egy szakasz elejét és végét a BEGIN és END szolgáltatásszavak jelölik, amelyek operátori zárójelek. E szavak közé kerül az algoritmus összes Pascal-ban írt parancsa (operátorok). Az operátorelválasztó pontosvessző. A program legvégére egy pont kerül. BEGIN READ(beviteli lista); READLN(beviteli lista); változó:=számtani kifejezés; WRITE(kimeneti lista); WRITELN(kimeneti lista); VÉGE.

10 csúszda

A kezdeti adatok bevitele a billentyűzetről a READ vagy a READLN (olvasás) operátorral történik. A READLN utasítás csak annyiban tér el a READ-tól, hogy az adatok bevitele után a kurzor az elejére kerül új sor. változó:=számtani kifejezés; WRITE(kimeneti lista); WRITELN(kimeneti lista); VÉGE. READ(beviteli lista); READLN(beviteli lista);

11 csúszda

változó:=számtani kifejezés; Aritmetikai hozzárendelési operátor: bal oldalon egy változó, jobb oldalon egy kiértékelendő aritmetikai kifejezés. Az összetett karakter:= „hozzárendelésként” olvasható. Először az aritmetikai kifejezést értékeljük ki, majd a kapott értéket hozzárendeljük egy változóhoz Példa: a:= sqr (x) + sin (y) / (12*z + 5)

12 csúszda

mod div / * - + SIN (x) COS (x) SQR (x) SQRT (x) ABS (x) Sin x Cos x x 2 |x| x összeadás kivonás szorzás osztás egész szám osztás osztás maradéka

13 csúszda

A számtani kifejezések írásának szabályai A számtani kifejezést egy karakterláncba írjuk Nem rakhatunk egymás után két számtani művelet előjelét Nem hagyhatjuk ki a szorzójelet a tényezők között Csak zárójeleket használunk A műveletek sorrendjét a prioritásuk határozza meg () F(x ) * / + - div mod

14 csúszda

Az eredmények kimenete WRITE vagy WRITELN (írás) segítségével történik. Az eredmények a felsorolás sorrendjében jelennek meg. A WRITE és WRITELN utasítások végrehajtása között az a különbség, hogy a WRITELN utasításon végrehajtott kimeneti művelet után a kurzor egy új sor elejére lép. WRITE(kimeneti lista); WRITELN(kimeneti lista);

15 csúszda

1. feladat: AXby 6) TU154 2) R&B 3) 4 kerék 4) Vasya 5) „PesBarbos” 7) 8) _ABBA 9) A+B

16 csúszda

programfeladat1; var a, b: egész szám; x, y: valós; kezdődik a:= 5; 10:=x; y: = 7,8; b:= 2,5; x:= 2*(a + y); a:= b + x; vége. a változó nevének az előjeltől balra kell lennie:= egész szám és a tört részek vesszővel vannak elválasztva, és típushibák Típushibák 2. FELADAT: Hibák keresése a programbejegyzésben.



Betöltés...
Top