Typy wyrażenia, schematy blokowe, writeln, readln, if, pętle

Niestandardowe typy proste type nazwa_typu = opis_typu; Typy wyliczeniowe type nazwa_typu = (pierwszy_identyfikator, drugi, ..., ostatni); Typy okrojone type nazwa_typu = stała1 .. stała2;

Typ wyliczeniowy type nazwa_typu = (pierwszy_identyfikator, drugi, ..., ostatni); np.: program typy_3; type dtyg = (pn, wt, sr, cz, pt, so, ni); var d: dtyg; begin d := pn; d := succ(d); { wtorek (poznamy za chwilę succ())} writeln(d) { źle! Nie da się wypisać! } end.

Typ okrojony np.: type nazwa_typu = stała1 .. stała2; {stała1 < stała2, obie tego samego typu porządkowego} np.: type litera = ’A’..’Z’; drob = pn..pt; { po zdefiniowaniu dtyg w poprz. przykł. } zakres = 1 .. 100;

Konwersje porządkowy na liczbę całkowitą na dowolny typ ord(wyrażenie); na dowolny typ nazwa_typu(wyrażenie); np.: dtyg(2)=sr

Typy anonimowe zamiast można nie definiować nazwy typu type dtyg = (pn, wt, sr, cz, pt, so, ni); var d: dtyg; można nie definiować nazwy typu d: (pn, wt, sr, cz, pt, so, ni); {OK.} d: (pn, wt, sr, cz, pt, so, ni); {blad: redeklaracja pn, wt … }

Zgodność typów Dwa typy są zgodne jeżeli: są to typy takie same, lub jeden z nich jest okrojonym typem drugiego albo obydwa są okrojonymi typami tego samego typu pierwotnego, lub obydwa są typami zbiorowymi o zgodnych typach podstawowych. T2 jest zgodny w sensie przypisania z T1, jeżeli: T1 i T2 są tym samym typem (nie dotyczy typu plikowego), T1 i T2 są zgodnymi typami porządkowymi i wartość typu T2 należy do typu T1, T1 i T2 są typami zbiorowymi i wszystkie elementy wartości typu T2 należą do typu podstawowego typu T1.

abs, sqr, sin, cos, arctan, exp, ln, sqrt, int (TP) Wyrażenia Operatory i funkcje Operatory dla liczb rzeczywistych: + - * / Funkcje dla liczb rzeczywistych: abs, sqr, sin, cos, arctan, exp, ln, sqrt, int (TP) Funkcje dla liczb rzeczywistych, wynik integer: round, trunc

+ - * mod div and or xor not shl shr Wyrażenia Operatory dla liczb całkowitych: + - * mod div and or xor not shl shr Operator dla liczb całkowitych, wynik rzeczywisty: / Funkcje dla liczb całkowitych: odd()

Wyrażenia Funkcje dla typów porządkowych: pred(t), succ(t) Funkcje operujące na typach: sizeof(T)

Przykłady wyrażeń 2+2, 2*(3+4), (1+2)/(3+4), (a+4)/17.45, (wynik rzeczywisty) ln(x), sqr(x), sqrt(x), sin(x)/cos(x) (nie ma tan(x)!), sqr(sin(x))+sqr(cos(x))

Typy złożone tablice rekordy zbiory pliki

Tablice jednowymiarowe type typ_tab = array [typ_porządkowy] of typ_elementów; dtyg = (pn, wt, sr, cz, pt, so, ni); typ_tab = array [dtyg] of integer; t10 = array [1..10] of real;

Tablice jednowymiarowe Mając zdefiniowany typ tablicowy zadeklarujemy tablice: var tab1: typ_tab; tab2: t10; … tab1[ni]:=0; tab1[pn]:=5+tab1[ni]; writeln(tab1[pn]);

Ograniczenia pamięci systemu Turbo Pascal i DOS type tint = array [integer] of char; {za duzy typ !!!}

Poprawność zakresów W TurboPascalu: {$R+} {tutaj poprawność sprawdzana w trakcie biegu programu, a nie tylko kompilacji – indeksy mogą być wyrażeniami} {$R-}

Tablice wielowymiarowe Tablica, której elementami są tablice: (array[...] of array [...] of ...) składnia uproszczona: type typ_tab = array [tporz1,tporz2,tporz3] of typ_elementów; np.: var a = array [’a’..’z’,0..4] of real; (...) a[’b’,3]:=3.1415;

Łańcuchy znakowe Typ dla przechowywania łańcuchów znaków var s1: string; { do 255 znaków } s3: string[20]; { do 20 znaków }

Łańcuchy znakowe Przykłady operacji na łańcuchach s1 := ’Przykładowy tekst’; writeln(s1); s1 := ’To jest ’ + s1; Reprezentacja typu string w pamięci łańcuch jako tablica znaków indeksowana od 1 length(łańcuch)

Schematy blokowe (a) blok graniczny (początek / koniec (stop)); (b) blok wejścia-wyjścia; (c) blok obliczeniowy; (d) blok decyzyjny; (e) blok wywołania podprogramu; (f) blok fragmentu (“makro” rozpisane w innym miejscu); (g) komentarz; (h) łącznik wewnątrzstronicowy; (i) łącznik międzystronicowy

Schematy blokowe Do każdego bloku może dochodzić dowolna liczba strzałek. Każda z nich oznacza wykonanie wszystkich czynności danego bloku. Z każdego bloku, z wyjątkiem bloku decyzyjnego, może wychodzić tylko jedna strzałka. Z bloku decyzyjnego moszą wychodzić dwie strzałki oznaczone odpowiednio “Tak” oraz “Nie”. Blok graniczny lub łącznik jest pozbawiony jednej ze strzałek dochodzącej lub wychodzącej. Pozostałe bloki muszą mieć zarówno strzałkę dochodzącą, jak i wychodzącą. Schemat działania programu powinien być uzupełniony listą nazw, zawierającą nazwy wszystkich zmiennych użytych w programie wraz z wyjaśnieniem spełnianej funkcji.

Schematy blokowe program test_4; var x: real; begin x := 2.5;          x := 2*x;          writeln(x)       end.

Procedury standardowe writeln i write writeln a write writeln(’Hello, world’); write(’Hello,’); writeln(’ world’); writeln;

Procedury standardowe writeln i write działa dla tyów standardowych prostych oraz dla string można wywoływać z wieloma argumentami write(x,y); {2 arg, zlepia się!} write(x,’ ’,y); {3 arg, czytelnie}

Procedury standardowe writeln i write formatowanie k=123; writeln(’>’,k,’<’); writeln(’>’,k:5,’<’); writeln(’>’,k:2,’<’); >123< > 123<

Procedury standardowe writeln i write formatowanie, typ real (0 – szer. domyślna) writeln(’>’,Pi,’<’); writeln(’>’,Pi:0,’<’); writeln(’>’,Pi:0:3,’<’); writeln(’>’,Pi:8:3,’<’); writeln(’>’,-Pi,’<’); writeln(’>’,-Pi:0:3,’<’); > 3.1415926536E+00< > 3.1E+00< >3.142< > 3.142< >-3.1415926536E+00< >-3.142<

Procedury standardowe readln i read read(nazwa_zmiennej); read a readln, buforowanie program czytanie; var d: integer; begin write(’Podaj liczbę: ’); readln(d); writeln(’d*d=’,sqr(d)) end.

Instrukcje sterujące

Instrukcja if if warunek then instrukcja; program inst_war; var d: integer; begin write(’Podaj liczbę: ’); readln(d); if d>0 then writeln(’d jest dodatnie’); writeln(’Koniec’) end.

Instrukcja złożona begin instrukcja_1; instrukcja_2; ... instrukcja_n end program inst_war; var d: integer; begin write(’Podaj liczbę: ’); readln(d); if d>0 then writeln(’d jest dodatnie’); writeln(’d= ’, d); end; writeln(’Koniec’) end.

Instrukcja złożona program inst_war2; var d,d0: integer; begin write(’Podaj liczbę: ’); readln(d); d0 := d; { zapamiętanie początkowej wartości d } if d<0 then writeln(’Podano liczbę ujemną.’); d := -d; { wyznaczamy liczbę przeciwną } end; { konieczny średnik! } writeln(’Abs(’,d0,’)=’,d) end.

Instrukcja alternatywy if warunek then instrukcja_1 else instrukcja_2; przed else nie może wystąpić średnik

Instrukcja alternatywy program inst_alt; var d: integer; begin write(’Podaj liczbę: ’); readln(d); if d>0 then writeln(’d jest dodatnie’) else if d<0 then writeln(’d jest ujemne’) writeln(’d jest zerem’) writeln(’Koniec’) end.

Iteracje: pętla while while warunek do instrukcja;

Iteracje: pętla while program wysnaczenie potegi liczby; var n,wynik: integer; begin write(’Do której potęgi podnieść 2:’ ); readln(n); { n powinno być nieujemne!!! Nie sprawdzamy tego. } wynik:=1; while n > 0 do wynik:=2*wynik; n:= n-1 { albo dec(n) } end; writeln(’wynik=’,wynik) end.

Iteracje: pętla repeat instrukcja_1; instrukcja_2; ... instrukcja_n until warunek;

Iteracje: pętla repeat program przyk_repeat; var n: integer; begin repeat write(’Podaj liczbę nieujemną: ’); readln(n); if n<0 then writeln(’To jest liczba ujemna!’); until n>=0; writeln(’W porządku.’) end.

Iteracje: pętla for for zm_ster := wart_pocz to wart_końc do instrukcja; wariant downto

Iteracje: pętla for zmienną sterującą zm_ster może być tylko zmienna typu porządkowego (np. integer, char, typ wyliczeniowy); wart_pocz oraz wart_końc muszą być wyrażeniami tego samego typu, co zmienna sterująca; instrukcja umieszczona wewnątrz pętli nie może zmieniać wartości zmiennej sterującej; po zakończeniu wykonywania pętli wartość zmiennej sterującej jest nieokreślona (nie wolno zakładać, że jest ona równa następną wartością po wart_końc). Czyli schemat blokowy niezupełnie odpowiada rzeczywistości.

Iteracje: pętla for program przyk_for; var c: char; begin for c:=’a’ to ’z’ do write(c); writeln; end.

break i continue Występują tylko w Turbo Pascalu Instrukcja break powoduje natychmiastowe zakończenie wykonywania najbardziej wewnętrznej z pętli while, repeat lub for, w jakiej została zapisana. Jeśli zostanie umieszczona poza pętlą, to kompilator zgłosi błąd. Instrukcja continue również może być stosowana tylko w pętlach. Powoduje przejście do następnej iteracji, czyli pominięcie wszystkich instrukcji w wnętrza pętli „aż do zapętlenia”. Dla instrukcji while i repeat oznacza to natychmiastowe przejście do sprawdzania warunku, dla for - do modyfikacji zmiennej sterującej i sprawdzania warunku.

Przykłady Zapisać bez użycia for instrukcję for z:=w1 to w2 do I

Przykłady Zapisać bez użycia for instrukcję for z:=w1 to w2 do I z:=w1; {rozwiązanie typowe} while z<=w2 do begin I; z:=succ(z) end;

Przykłady Zapisać bez użycia repeat instrukcję repeat I1; I2; ...; In until warunek;

Przykłady Zapisać bez użycia repeat instrukcję repeat I1; I2; ...; In until warunek; z:=w1; while z<=w2 do begin I1; I2; ...; In; while not warunek do I1; I2; ...; In end;

Przykłady Zapisać bez użycia while instrukcję while warunek do I;

Przykłady Zapisać bez użycia while instrukcję while warunek do I; if warunek then repeat I until not warunek;

Przykłady Wypisać na ekranie tabliczkę mnożenia do 10. 1 2 3 4 5 6 7 8 9 10 1: 1 2 3 4 5 6 7 8 9 10 2: 2 4 6 8 10 12 14 16 18 20 3: 3 6 9 12 15 18 21 24 27 30 4: 4 8 12 16 20 24 28 32 36 40 5: 5 10 15 20 25 30 35 40 45 50 6: 6 12 18 24 30 36 42 48 54 60 7: 7 14 21 28 35 42 49 56 63 70 8: 8 16 24 32 40 48 56 64 72 80 9: 9 18 27 36 45 54 63 72 81 90 10: 10 20 30 40 50 60 70 80 90 100

Przykłady program tmno; var a,b : integer; begin write(' '); for a:=1 to 10 do write(a:4); writeln; for b:=1 to 10 do begin write(b:2, ': '); for a:=1 to 10 do write(a*b:4); writeln; end end.

Przykłady wczytać 20 liczb całkowitych i wypisać je na ekran

Przykłady program tab20; var i : integer; tab : array [1..20] of integer; begin for i:=1 to 20 do read(tab[i]); writeln(i:2, ' ', tab[i]); end.

Przykłady wczytać 20 liczb całkowitych i wypisać je na ekran w odwrotnej kolejności

Przykłady program tab20; var i : integer; tab : array [1..20] of integer; begin for i:=20 downto 1 do read(tab[i]); for i:=1 to 20 do writeln(i:2, ' ', tab[i]); end.

Przykłady wczytać 20 liczb całkowitych do tablicy i wyszukać największą liczbę

Przykłady program max20; var i : integer; max: integer; tab : array [1..20] of integer; begin for i:=1 to 20 do read(tab[i]); max := tab[1]; for i:=2 to 20 do if tab[i]>max then max := tab[i]; end.

Przykłady wczytać 20 liczb całkowitych do tablicy i posortować tablicę

Przykłady program bubble; var i : integer; { licznik pętli } pom : integer; { pomocnicza } zamiany: boolean; {flaga - czy byly zamiany} tab : array [1..20] of integer; begin for i:=1 to 20 do { wczytaj } read(tab[i]); { posortuj } for i:=1 to 20 do { wypisz } writeln(i, ' ', tab[i]); end. { posortuj } repeat zamiany := false; for i:=1 to 19 do if tab[i]>tab[i+1] then begin pom := tab[i]; tab[i] := tab[i+1]; tab[i+1] := pom; zamiany := true; end until zamiany=false;