1
PODSTAWY PROGRAMOWANIA
W JĘZYKU PASCAL
1
PODSTAWY PROGRAMOWANIA
W JĘZYKU PASCAL
2
Spis treści
WPROWADZENIE DO PASCALA ................................................................................................... 3
OPERACJE ARYTMETYCZNE......................................................................................................... 4
INSTRUKCJA WARUNKOWA ......................................................................................................... 5
INSTRUKCJA WYBORU CASE........................................................................................................ 6
ITERACJA W PASCALU ................................................................................................................... 7
PROGRAMOWANIE STRUKTURALNE ......................................................................................... 9
FUNKCJE .......................................................................................................................................... 10
STRUKTURY DANYCH – TABLICE ............................................................................................. 11
REKURENCJA .................................................................................................................................. 12
TYP REKORDOWY ......................................................................................................................... 13
ZMIENNE PLIKOWE ....................................................................................................................... 14
TRYB GRAFICZNY ......................................................................................................................... 17
3
WPROWADZENIE DO PASCALA
1. Struktura programu:
PROGRAM nazwa;
deklaracja zmiennych;
BEGIN
część wykonawcza;
END.
W części deklaracyjnej dołącza się moduły zewnętrzne zawierające dodatkowe procedury i funkcje
nie znajdujące się w części standardowej (np. USES CRT), deklaruje się wszystkie zmienne
uŜywane w programie oraz definiuje procedury i funkcje.
Część wykonawcza to zapisany w postaci instrukcji algorytm.
KaŜda instrukcja w Pascalu powinna być zakończona symbolem ”;”, cały program kończy się
kropką.
Wszelkie komentarze w programie zapisuje się ograniczając je nawiasami sześciennymi. Wielkość
czcionki nie ma w Pascalu znaczenia, jednak ze względu na przejrzystość kodu programu,
wskazane jest, aby słowa kluczowe pisać wielkimi literami.
2. Deklaracja zmiennych:
VAR nazwa_zmiennej:typ zmiennej;
Podstawowe typy zmiennych:
INTEGER – liczby całkowite z przedziału <-32768;32767>
REAL – liczby rzeczywiste
STRING – łańcuch znaków (do 256 znaków), długość łańcucha moŜna ograniczyć do n znaków
(STRING[n])
CHAR –znak
Przykład:
VAR x:INTEGER;
nazwisko, imie:STRING[20];
3. Wprowadzanie danych i wyprowadzanie wyników:
WRITE(lista_argumentów) – wyprowadzenie na ekran wartości z listy podanych argumentów
np. WRITE(‘wynik wynosi: ‘,x); - na monitorze pojawi się tekst „wynik wynosi: „ oraz wartość
zmiennej x.
WRITELN(lista_argumentów); - j/w z tym, Ŝe po wypisaniu argumentów kursor automatycznie
przeniesiony jest do nowego wiersza
READLN(lista_zmiennych); - wczytanie wartości do podanych zmiennych. Program zatrzymuje się
i wznawia działanie po podaniu wartości i zatwierdzeniu jej klawiszem „enter”.
4. Procedury ustalające kolor tekstu i tła oraz ustawienie kursora:
TEXTBACKGROUND(kolor); - ustalenie koloru tła na kolor podany w jęz. angielskim lub poprzez
numer koloru (od 0 do 15)
TEXTCOLOR(kolor); - ustalenie koloru czcionki
GOTOXY(x,y); - ustawienie kursora w kolumnie nr x i wierszu nr y (licząc od lewego górnego
rogu)
4
Przykład:
PROGRAM pierwszy;
USES crt;
{dodanie modułu crt}
VAR nazwisko:STRING[20];
wiek:INTEGER;
BEGIN
clrscr;
{czyszczenie ekranu}
WRITE(‘Podaj nazwisko: ‘);
READLN(nazwisko);
{wczytanie podanej wartości do zmiennej „nazwisko”}
WRITE(‘Podaj wiek: ‘);
READLN(wiek);
{ wczytanie podanej wartości do zmiennej „wiek”}
clrscr;
WRITELN(‘Twoje nazwisko: ‘,nazwisko);
{wypisanie podanych wartości}
WRITELN((‘Twój wiek: ‘,wiek);
REPEAT UNTIL KEYPRESSED;
{zatrzymanie działania programu}
END.
{do momentu wciśnięcia dowolnego przycisku}
OPERACJE ARYTMETYCZNE
1. Operatory arytmetyczne:
„+” dodawanie
„-” odejmowanie
„*” mnoŜenie
„/” dzielenie
„DIV” część całkowita z dzielenia
„MOD” reszta z dzielenia
„SQR” druga potęga
„SQRT” pierwiastek kwadratowy
2. Operatory logiczne:
„NOT” negacja, np. NOT (x>0)
„AND” koniunkcja, np. (x>0) AND (x<10)
“OR” alternatywa np. (x>0) OR (x<10)
“XOR” róŜnica logiczna, np. (x>0) XOR (x<10)
Wartości poszczególnych operacji logicznych:
X
Y
NOT (X) X AND Y X OR Y
X XOR Y
0
0
1
0
0
0
0
1
1
0
1
1
1
0
0
0
1
1
1
1
0
1
1
0
3. Relacje
“=” równe
“<>” nierówne
“<” mniejsze
“>” większe
“<=” mniejsze równe
„>=” większe równe
5
Przykład:
PROGRAM dzialania;
USES crt;
VAR x,y:INTEGER;
BEGIN
clrscr;
WRITE('Podaj pierwsza liczbe: ');
READLN(x);
WRITE('Podaj druga liczbe: ');
READLN(y);
WRITELN;WRITELN;WRITELN;
WRITELN(x,'+',y,'=',x+y);
WRITELN(x,'-',y,'=',x-y);
WRITELN(x,'*',y,'=',x*y);
WRITELN(x,'/',y,'=',x/y:1:2);
WRITELN(x,' DIV ',y,' = ',x DIV y);
WRITELN(x,' MOD ',y,' = ',x MOD y);
WRITELN('SQR (x) = ',SQR(x));
WRITELN('SQRT (x) = ',SQRT(x):1:2);
READLN;
END.
INSTRUKCJA WARUNKOWA
Postać instrukcji warunkowej:
IF wyraŜenie THEN instrukcja;
lub
IF wyraŜenie THEN instrukcja1 ELSE instrukcja2;
np.
IF x>0 THEN WRITELN(‘liczba dodatnia’);
lub
IF x>0 THEN WRITELN(‘liczba dodatnia’) ELSE WRITELN(‘liczba niedodatnia’);
Przykład 1:
PROGRAM warunek;
{warunek prosty}
USES crt;
VAR x,y:INTEGER;
BEGIN
clrscr;
WRITELN('Program liczy wartosc bezwzgledna podanej liczby');
DELAY(2000);
{zatrzymanie działania programu na ok. 2 sekundy}
clrscr;
WRITE('Podaj liczbe: ');
READLN(x);
IF x>=0 THEN y:=x ELSE y:=-x;
WRITELN('|',x,'|=',y);
READLN;
END.
6
Przykład 2:
PROGRAM warunek1;
{warunek zagnieŜdŜony}
USES crt;
VAR x,y:INTEGER;
BEGIN
clrscr;
WRITE('x=');
READLN(x);
WRITE('y=');
READLN(y);
WRITELN;WRITELN;
IF (x<0) AND (y<0) THEN WRITELN('Obie liczby sa ujemne')
ELSE IF (x>0) AND (y>0) THEN WRITELN('Obie liczby sa dodatnie')
ELSE WRITELN('Liczby sa roznych znakow');
READLN;
END.
Zadania:
1. Program wczytuje dwie liczby całkowite i symbol działania, a następnie wykonuje to działanie na
tych liczbach.
2. Program rozwiązuje równanie liniowe.
3. Program rozwiązuje równanie kwadratowe.
4. Program rozwiązuje układ dwóch równań liniowych.
INSTRUKCJA WYBORU CASE
Instrukcja wyboru pozwala na wykonanie pewnych instrukcji w zaleŜności od wartości wyraŜenia
zwanego selektorem.
CASE wyraŜenie OF
lista_1: instrukcja_1;
lista_2: instrukcja_2;
.......
lista_n: instrukcja_n
ELSE insrukcja;
END;
Przykłady:
PROGRAM case1;
USES crt;
VAR x,y:INTEGER; w:REAL; d:CHAR;
BEGIN
clrscr;
WRITE('x='); READLN(x); WRITE('y='); READLN(y);
WRITE('Podaj dzialanie (+,-,*,/): '); READLN(d);
CASE d OF
'+': w:=x+y;
'-': w:=x-y;
'*': w:=x*y;
7
'/': w:=x/y;
ELSE BEGIN WRITELN('Nie ma takiego dzialania!'); readkey; HALT; END;
END;
WRITELN(x,d,y,'=',w:1:2);
readkey;
END.
PROGRAM case2;
USES crt;
VAR miesiac:1..12; l_dni:byte;
BEGIN
clrscr;
WRITE('Podaj numer miesiaca: '); READLN(miesiac);
CASE miesiac OF
1, 3, 5, 7, 8, 10, 12: l_dni:=31;
2: l_dni:=28;
ELSE l_dni:=30;
END;
WRITELN('Ten miesiac ma ',l_dni,' dni');
readkey;
END.
Zadania:
1. Program do obliczania Ŝądanej funkcji trygonometrycznej kąta podanego w stopniach. UŜywane
funkcje: sin(x), cos(x), gdzie x jest miarą kąta wyraŜoną w radianach.
2. Program do obliczania pola powierzchni jednej z figur: prostokąta, trójkąta lub trapezu. W
programie wykorzystać naleŜy procedury do wczytywania danych i obliczania pola.
ITERACJA W PASCALU
1. Pętla FOR – stosowana jest wtedy, gdy znana jest liczba kroków iteracji.
FOR zmienna:=wyraŜenie1 TO wyraŜenie2 DO instrukcja;
TO – przy wzrastaniu wartości zmiennej, DOWNTO – przy zmniejszaniu się wartości zmiennej.
Zmienna musi być typu całkowitego.
Np.
FOR i:=1 TO 10 DO BEGIN
k:=i*i;
WRITELN(k);
END;
Pętla zagnieŜdŜona:
FOR i:= 1 TO k DO BEGIN
FOR j:=1 TO n DO WRITE(‘*’);
WRITELN;
END;
Przykład:
PROGRAM petla_FOR;
USES crt;
8
VAR i,n,suma:INTEGER;
BEGIN
clrscr;
WRITELN('Wypisywanie zadanej ilosci liczb naturalnych i ich sumowanie');
WRITE('Podaj wartosc koncowa: ');
READLN(n); WRITELN;
suma:=0;
FOR i:=1 TO n DO BEGIN
WRITE(i:5);
suma:=suma+i;
WRITELN(suma:10);
READLN;
END;
WRITELN; WRITELN('KONIEC!!!');
repeat until keypressed;
END.
Zadania:
1. Rysowanie wypełnionego prostokąta o zadanych wymiarach z zadanych znaków.
2. Rysowanie pustego prostokąta o zadanych wymiarach z zadanych znaków.
3. Wypisywanie n kolejnych liczb parzystych.
4. Obliczanie silni liczby n.
PoniŜsze instrukcje pozwalają na powtarzanie zawartych wewnątrz pętli instrukcji tak długo, aŜ
zostanie spełniony (repeat) lub przestanie być spełniony (while) zadany warunek.
2. Instrukcja „dopóki”
SłuŜy do FORmułowania zadania iteracyjnego ze sprawdzaniem warunku na początku pętli
WHILE warunek DO instrukcja;
(Dopóki spełniony jest podany warunek, wykonuj instrukcję.)
Np.
WRITE(‘a= ‘);
READLN(a);
WHILE a<=0 DO BEGIN
WRITELN(‘Złe dane! Podaj wartość dodatnią’);
WRITE(‘a= ‘);
READLN(a);
END;
2. Instrukcja „powtarzaj”
SłuŜy do FORmułowania zadania iteracyjnego ze sprawdzaniem warunku na końcu pętli
REPEAT instrukcja UNTIL warunek;
(Powtarzaj instrukcję aŜ do momentu, gdy spełniony będzie podany warunek.)
Np.
REPEAT
WRITE(‘a= ‘);
READLN(a);
IF a<=0 THEN WRITELN(‘Złe dane! Podaj wartość dodatnią’);
UNTIL
a>0;
9
Przykład:
PROGRAM losowanie;
USES crt;
VAR x,y,licznik:INTEGER;
BEGIN
clrscr;
licznik:=0;
randomize;
x:=random(10);
WRITE('Odgadnij liczbe od 0 do 9: ');
repeat
READLN(y);
WHILE (y<0) OR (y>9) DO BEGIN
WRITE('Od 0 do 9!!!: ');
READLN(y);
END;
IF y<x THEN WRITELN('Za mala, sprobuj jeszcze raz')
ELSE IF y>x THEN WRITELN('Za duza, sprobuj jeszcze raz');
WRITELN;
licznik:=licznik+1;
UNTIL y=x;
WRITELN('Udalo Ci sie za ',licznik,' razem');
repeat until keypressed;
END.
Zadania:
1. Napisać program wczytujący i sumujący kolejno wprowadzane liczby całkowite, aŜ do momentu,
gdy suma przekroczy wartość 1000.
2. Napisać program wypisujący dzielniki wprowadzonej liczby naturalnej.
3. Program wczytuje dwie liczby całkowite a oraz b (a
≠
0) a następnie liczy i wypisuje wartość
potęgi
b
a
4. Program wczytuje w pierwszym wierszu stopień wielomianu W(x), w drugim argument x, a w
następnych wartości współczynników
0
1
2
1
,
,...,
,
,
a
a
a
a
a
n
n
n
−
−
. Na wyjściu wypisuje wartość tego
wielomianu dla argumentu x.
PROGRAMOWANIE STRUKTURALNE
Procedura (funkcja) – wyodrębniony fragment programu, REALizujący określone zadanie, który
moŜe być wielokrotnie wykorzystywany w programie. Procedurę i funkcję definiuje się w części
deklaracyjnej programu, a wywołuje w części głównej.
Przykład 1:
PROGRAM strukturalne1;
{wypisywanie gwiazdek w kształcie prostokąta}
USES crt;
VAR i,m:INTEGER;
PROCEDURE gwiazdki;
{początek definicji procedury}
VAR k:INTEGER;
BEGIN
FOR k:=1 to 20 do WRITE('*');
10
WRITELN;
END;
{koniec definicji procedury}
BEGIN
clrscr;
WRITELN('Podaj ile rzedow wyswietlic: ');
READLN(m); clrscr;
FOR i:=1 TO m DO gwiazdki;
{wywołanie procedury}
readkey;
{zatrzymanie do momentu wciśnięcia dowolnego klawisza}
END.
Przykład 2:
PROGRAM strukturalne2;
{wypisywanie dzielników liczby naturalnej}
USES crt;
VAR m:INTEGER;
PROCEDURE dzielniki(a:INTEGER);
{początek definicji procedury}
VAR k:INTEGER;
BEGIN
FOR k:=1 TO a DO IF (a mod k)=0 THEN WRITE(k,', ');
END;
{koniec definicji procedury}
BEGIN
clrscr;
WRITELN('Podaj liczbe naturalna: '); textcolor(red);
READLN(m); textcolor(white);
WRITELN('Dzielnikami tej liczby sa: '); textcolor(red);
dzielniki(m);
{wywołanie procedury}
readkey;
END.
Zadania:
1. Napisz program wyświetlający na ekranie monitora a) trójkąt prostokątny z gwiazdek, b)
choinkę z podanego symbolu.
2. Napisz program wypisujący 10 początkowych wielokrotności podanej liczby naturalnej.
3. Napisz program generujący prostą melodię w oparciu o standardowe procedury:
SOUND(h) – generowanie dźwięku o częstotliwości h Hz, DELAY(t) – zatrzymanie działania
programu na czas t jednostek (około 5000 odpowiada czasowi 1 sekundy), NOSOUND –
wyłączenie dźwięku.
FUNKCJE
Struktura funkcji:
FUNCTION nazwa_funkcji (lista parametrów FORmalnych): typ wyniku;
część deklaracyjna funkcji;
BEGIN
ciąg instrukcji;
END;
Ciąg instrukcji występujących wewnątrz definicji funkcji musi zawierać przypisanie:
nazwa_funkcji:=wyraŜenie, ustalające wartość zwracaną przez funkcję
Przykład 1:
FUNCTION max(x,y:INTEGER): INTEGER;
VAR p:INTEGER;
11
BEGIN
IF x>=y THEN p:=x ELSE p:=y;
max:=p;
END;
Przykład 2:
FUNCTION f_lin(a,b,x:REAL): REAL;
BEGIN
f_lin:=a*x+b;
END;
Zadania:
1. Program oblicza wartość funkcji kwadratowej
2. Program pozwala obliczyć wartość dowolnego wielomianu (maksymalnie do 4 stopnia)
3. Program liczy potęgę całkowitą dowolnej liczby rzeczywistej.
4. Program liczy średnią arytmetyczną dwóch podanych liczb całkowitych
STRUKTURY DANYCH – TABLICE
1. Podstawowe typy danych:
a) typ prosty:
- typ porządkowy (m.in. całkowity, logiczny, znakowy)
- typ rzeczywisty
b) typ łańcuchowy
c) typ strukturalny (m.in. tablicowy, rekordowy)
Podzbiory typu całkowitego:
- INTEGER: <-32768; 32767>
- WORD: <0; 65535>
- BYTE: <0; 255>
- SHORTINT: <-128; 127>
- LONGINT: <-2147483648; 2147483647>
2. Typ tablicowy.
Tablica – złoŜona struktura danych, składająca się z określonej liczby elementów tego samego
typu.
Deklaracja tablicy:
VAR zmienna:ARRAY[1..n] OF typ_elementów_tablicy;
Przykład:
PROGRAM tablica;
USES crt;
VAR i:INTEGER;
imiona:ARRAY[1..5] OF STRING[10];
BEGIN
clrscr;
FOR i:=1 TO 5 DO {wczytywanie do tablicy}
BEGIN
WRITE('Podaj ',i,' imie: ');
READLN(imiona[i]);
END;
clrscr;
12
FOR i:=1 TO 5 DO {wypisywanie elementow tablicy}
BEGIN
textcolor(i);
WRITELN(imiona[i]);
END;
readkey;
END.
Zadania:
1. Napisać program wczytujący 20 znaków (cyfry, litery) a następnie liczący ile razy wczytano
literę „a”
2. Zmodyfikować powyŜszy program tak, aby zliczał Ŝądane znaki.
REKURENCJA
Rekurencja polega na odwoływaniu się do określanego pojęcia w trakcie jego definicji.
Np. definicja silni:
>
⋅
−
=
=
0
!
1
(
0
1
!
n
dla
n
n
n
dla
n
Przykład 1:
{
rekurencyjne obliczanie silni}
PROGRAM silnia_rek;
USES crt;
VAR n:INTEGER; s:LONGINT;
FUNCTION srek(k:INTEGER):LONGINT;
BEGIN
IF k=1 THEN srek:=1 ELSE srek:=k*srek(k-1);
END;
BEGIN
CLRSCR;
WRITELN('Obliczanie silni');
WRITE('n='); READLN(n);
s:=srek(n);
WRITELN(n,'!=',s);
READKEY;
END.
Przykład 2:
{algorytm Euklidesa – wykorzystanie rekurencji}
PROGRAM euklides_rek;
USES crt;
VAR a,b,s:INTEGER;
FUNCTION eu(k,l:INTEGER):INTEGER;
BEGIN
IF k=l THEN eu:=k ELSE if k>l THEN eu:=eu(k-l,l) ELSE eu:=eu(k,l-k);
END;
BEGIN
CLRSCR;
WRITELN('Obliczanie NWD liczb a i b');
WRITE('a=');
READLN(a);
13
WRITE('b=');
READLN(b);
s:=eu(a,b);
WRITELN('NWD(',a,',',b,')=',s);
READKEY;
END.
Zadania
1. Napisać program wyznaczający n-tą liczbę trójkątną.
2. Napisać program wypisujący n-tą liczbę parzystą
3. Napisać program wypisujący n-tą potęgę liczby k.
4. Napisać program realizujący schemat Hornera
5. Napisać program wypisujący n-tą liczbę Fibonacciego
TYP REKORDOWY
Rekordem nazywamy obiekt złoŜony, którego składowe, zwane polami mogą być róŜnych typów
(w odróŜnieniu od tablicy, gdzie elementy są tego samego typu).
Deklaracja zmiennej rekordowej:
VAR zmienna:RECORD
pole_1
:typ;
..................
pole_n
:typ
END;
Odwoływanie się do pól rekordu:
- przez kropkę: nazwa_rekordu.nazwa_pola
- instrukcją with: with nazwa_rekordu do instrukcja
Przykład:
PROGRAM rekordy;
USES crt;
type osoba=RECORD
nazwisko:STRING[12];
imie:STRING[12];
wiek:INTEGER;
plec:CHAR
END;
VAR x:osoba;
BEGIN
clrscr; WRITELN('Wczytywanie danych osobowych');
textcolor(2); WRITE('nazwisko: ':15); textcolor(4); READLN(x.nazwisko);
textcolor(2); WRITE('imie: ':15); textcolor(4); READLN(x.imie);
textcolor(2); WRITE('wiek: ':15); textcolor(4); READLN(x.wiek);
textcolor(2); WRITE('plec (m/k): ':15); textcolor(4); READLN(x.plec);
clrscr; textcolor(14);
with x do WRITE(nazwisko,' ',imie,', ',wiek,' lat, ');
IF x.plec='m' THEN WRITELN('mezczyzna') ELSE IF x.plec='k' THEN
WRITELN('kobieta') ELSE WRITELN('nie wiadomo co');
readkey;
END.
14
Zadania:
1. Zmodyfikuj powyŜszy program tak, aby wczytywał dane pięciu osób (uŜyj 5-elementowej tablicy
rekordów) a następnie wypisywał dane osoby o Ŝądanym nazwisku (aŜ do Ŝądania zakończenia
wypisywania).
ZMIENNE PLIKOWE
Typ plikowy jest ciągiem elementów tego samego typu lecz o zmiennej liczbie składowych,
uzaleŜnionej od wykonania programu. Plik jest modelem fizycznego zbioru danych o dostępie
sekwencyjnym. Oznacza to, Ŝe w danym momencie dostępny jest tylko jeden element pliku.
Deklaracja zmiennej plikowej:
VAR nazwa:FILE OF typ_elementów_pliku;
Słowa kluczowe związane z operacjami na plikach:
ASSIGN(zmienna plikowa, nazwa pliku) – skojarzenie zmiennej plikowej z plkiem o podanej
nazwie.
REWRITE(zmienna plikowa) – utworzenie nowego, pustego pliku.
Jeśli plik juŜ istnieje, to jego zawartość zostanie wykasowana.
RESET(zmienne plikowa) – otwarcie pliku i ustawienie wskaźnika na jego początku .
APPEND(zmienna plikowa) – otwarcie pliku i ustawienie wskaźnika na jego końcu, przygotowanie
do dopisywania elementów (dotyczy tylko plików tekstowych);
CLOSE(zmienna plikowa) – zamknięcie pliku.
WRITE(zmienna plikowa, zmienna zewnętrzna) – zapis do pliku na aktualnej pozycji zawartości
zmiennej zewnętrznej.
READ(zmienna plikowa, zmienna zewnętrzna) – odczyt z pliku z aktualnej pozycji do zmiennej
zewnętrznej.
SEEK(zmienna plikowa, pozycja) – ustawienie wskaźnika na podanej pozycji w pliku (nr pozycji
liczy się od zera).
FILEPOS(zmienna plikowa) – funkcja zwracająca wartość aktualnej pozycji w pliku.
FILESIZE(zmienna plikowa) – funkcja zwraca rozmiar aktualnego pliku.
Przykład:
PROGRAM pliki;
USES crt;
TYPE osoba=RECORD
nazwisko, imie:STRING[20];
wiek:INTEGER;
plec:CHAR;
END;
VAR plik:FILE OF osoba;
x:osoba;
nazwa,n:STRING;
odp:CHAR;
i:INTEGER;
PROCEDURE nowy_plik; {procedura tworzenia nowego pliku}
BEGIN {i wprowadzania danych}
15
clrscr;
WRITE('Podaj nazwe pliku w ktorym chcesz zachowac dane: ');
READLN(nazwa);
ASSIGN(plik,nazwa); {skojarzenie zmiennej plikowej z plikiem}
REWRITE(plik); {otwarcie pliku do wpisywania}
REPEAT
clrscr;
textcolor(2); WRITE('nazwisko: ':15); textcolor(4);
READLN(x.nazwisko);
textcolor(2); WRITE('imie: ':15); textcolor(4); READLN(x.imie);
textcolor(2); WRITE('wiek: ':15); textcolor(4); READLN(x.wiek);
textcolor(2); WRITE('plec: ':15); textcolor(4); READLN(x.plec);
WRITE(plik,x); {zapisanie tresci rekordu x do pliku}
gotoxy(20,20);
WRITE('Kontynuowac (t/n)? ');
READLN(odp);
UNTIL (odp='n') OR (odp='N');
CLOSE(plik); clrscr; textcolor(15); {zamkniecie pliku}
END;
PROCEDURE dopisywanie; {procedura dopisywania danych}
BEGIN
clrscr;
WRITE('Podaj nazwe pliku, w ktorym chcesz dopisywac: ');
READLN(nazwa);
ASSIGN(plik,nazwa);
RESET(plik); {otwarcie pliku do dopisywania}
SEEK(plik,filesize(plik)); {ustawienie wskaznika na koncu pliku}
clrscr;
textcolor(2); WRITE('nazwisko: ':15); textcolor(4);
READLN(x.nazwisko);
textcolor(2); WRITE('imie: ':15); textcolor(4); READLN(x.imie);
textcolor(2); WRITE('wiek: ':15); textcolor(4); READLN(x.wiek);
textcolor(2); WRITE('plec: ':15); textcolor(4); READLN(x.plec);
WRITE(plik,x);
CLOSE(plik); clrscr; textcolor(15);
END;
PROCEDURE wyswietlanie; {procedura wyswietlania danych}
BEGIN
clrscr;
WRITE('Podaj nazwe pliku z danymi: ');
READLN(nazwa);
WRITE('Podaj nazwisko osoby: ');
READLN(n);
clrscr; textcolor(14);
ASSIGN(plik,nazwa);
RESET(plik);
FOR i:=0 TO FILESIZE(plik)-1 DO {przegladanie pliku od pozycji}
BEGIN {zero do konca}
SEEK(plik,i); {ustawienie wskaznika na pozycji i}
READ(plik,x); {wczytanie aktualnego rekordu do}
16
IF x.nazwisko=n THEN {zmiennej x}
BEGIN
WITH x do WRITE(nazwisko,' ',imie,', ',wiek,' lat, ');
IF x.plec='m' THEN WRITELN('mezczyzna')
ELSE IF x.plec='k' THEN
WRITELN('kobieta') ELSE WRITELN('nie wiadomo co');
END;
END;
readkey;
CLOSE(plik); clrscr; textcolor(15);
END;
BEGIN
clrscr; textcolor(15);
REPEAT
WRITELN('Wybierz opcje');
WRITELN('a - tworzenie nowego pliku z danymi');
WRITELN('b - dopisywanie danych do pliku');
WRITELN('c - wyswietlanie danych ');
WRITELN('k - koniec pracy');
READLN(odp);
CASE odp OF
'a':nowy_plik;
'b':dopisywanie;
'c':wyswietlanie;
ELSE WRITELN('Nie ma takiej opcji');
END;
UNTIL (odp='k') OR (odp='K');
END.
PROGRAM pliki2;
USES crt;
VAR plik:file of INTEGER;
x,y:INTEGER;
nazwa:STRING[8];
odp:CHAR;
BEGIN
clrscr;
WRITELN('Podaj nazwe tworzonego pliku: ');
READLN(nazwa);
ASSIGN(plik,nazwa);
REWRITE(plik);
REPEAT
WRITELN('Podaj dwie liczby calkowite: ');
WRITE('x='); READLN(x);
WRITE('y='); READLN(y);
WRITE(plik,x); WRITE(plik,y);
WRITE('kontynuowac (t/n)? ');
READLN(odp);
UNTIL (odp='n') OR (odp='N');
CLOSE(plik)
END.
17
PROGRAM pliki3;
USES crt;
VAR plik:FILE OF INTEGER;
x,y,i:INTEGER;
nazwa:STRING[8];
BEGIN
clrscr;
WRITELN('Podaj nazwe pliku: ');
READLN(nazwa);
ASSIGN(plik,nazwa);
RESET(plik);
FOR i:=0 TO filesize(plik)-1 DO
BEGIN
SEEK(plik,i);
READ(plik,x);
WRITE(x,', ');
END;
CLOSE(plik);
readkey;
END.
Zadania:
1. Napisz program
a) wczytujący do pliku trzy liczby całkowite dodatnie
b) sprawdzający, czy z odcinków o długościach równych liczbom wczytanym do pliku w
poprzedni programie da się zbudować trójkąt.
2. Program jak wyŜej, tylko wczytać naleŜy nie jedną trójkę liczb, lecz dowolną ilość trójek.
TRYB GRAFICZNY
Tryb graficzny traktować naleŜy jako mozaikę punktów (pikseli) o wielkości ok. ¼ mm. KaŜdy
piksel ma swoje połoŜenie opisane współrzędnymi (dwie liczby dodatnie – punkt (0,0) to lewy
górny wierzchołek ekranu) oraz kolor.
Tryb graficzny naleŜy zainicjować (program ma standardowo ustawiony tryb tekstowy). SłuŜy do
tego procedura InitGraph(sterownik, tryb, ścieŜka dostępu do sterowników kart graficznych).
Sterownik i tryb to zmienne całkowite. Dzięki procedurze Detect program sam rozpoznaje kartę
graficzną. (sterownik:=Detect). Tryb graficzny powinien być na koniec programu zamknięty.
w opcjach programu (Options/Directories/Unit) musi byc ścieŜka do UNIT, np. d:\TP\UNITS
Przykład inicjowania i zamykania trybu graficznego:
PROGRAM graf;
USES crt, graph;
VAR ster,tryb:INTEGER;
BEGIN
clrscr;
ster:=detect; {wykrywanie trybu karty graficznej}
InitGraph(ster,tryb,'D:\TP\BGI'); {przejscie z trybu tekst. do graf.}
ReadKey;
18
CloseGraph;
END.
Podstawowe procedury graficzne:
SetBkColor(kolor) – kolor tła
SetColor(kolor) – kolor linii
PutPixel(x,y,c) – „zapalenie piksela o wsp. (x,y) kolorem c
Line(x1,y1,x2,y2) – rysowanie odcinka o końcach (x1,y1) i (x2,y2)
MoveTo(x,y) ustalenie pozycji początku odcinka dla procedury LineTo w punkcie (x,y)
LineTo(x,y) – rysowanie odcinka od ostatniego punktu do punktu (x,y)
Rectangle(x1,y1,x2,y2) – prostokąt o lewym górnym wierzchołku (x1,y1) i prawym dolnym (x2,y2)
Circle(x,y,r) – okrąg o środku (x,y) i promieniu r.
Ellipse(x1,y1,a1,a2,rx,ry) – wycinek elipsy o środku (x,y), promieniu poziomym rx i pionowym ry
poczynając od punktu odchylonego o kąt a1 i kończąc na punkcie odchylonym o kąt a2.
Arc(x,y,a1,a2,r) – łuk o środku (x,y) i promieniu r. o kącie początkowym a1 i końcowym a2.
OutTextXY(x,y,s) – wypisuje łańcuch tekstowy s zaczynając od punktu (x,y)
ClearViewPort – czyszczenie ekranu w trybie graficznym
Zadania
1. Program rysuje odcinek, prostokąt, okrąg i elipsę w róŜnych kolorach
2. Program rysuje koła olimpijskie
Inne procedury graficzne:*
MoveRel(dx,dy) – przemieszczanie wskaźnika o wektor [dx,dy]
LineRel(dx,dy) – rysowanie odcinka od aktualnej pozycji wskaźnika do punktu otrzymanego przez
przesunięcie punktu bieŜącego o wektor [dx,dy]
SetFillStyle(p,c) – ustalenie stylu i koloru wypełnianych obiektów; p - numer deseniu wypełnienia
(np. 1-kolor jednolity, 2-paski itd), c – kolor wypełnienia
Bar(x1,y1,x2,y2) – prostokąt wypełniony w sposób ustalony w/w procedurą
FillEllipse(x,y,rx,ry) – elipsa wypełniona w sposób ustalony procedurą SetFillStyle
PieSlice(x,y,a1,a2,r) – wypełniony j/w wycinek koła
FloodFill(x,y,c) – wypełnienie obszary ograniczonego konturem c, wewnątrz którego znajduje się
punkt o współrzędnych (x,y);
SetLineStyle(rodzaj,wzór,grubość) – ustalenie rodzaju linii; rodzaj – wielkość numeryczna: 0-linia
ciągła, 1-kropki, 2-kreska kropka itd, 3-kreski, wzór – istotny tylko w przypadku linii zdefiniowanej
przez uŜytkownika (w typowej sytuacji wstawić 0), grubość – 1-normalna, 3-pogrubiona
SetTextStyle(krój,kierunek,rozmiar) – krój - wielkość numeryczna: 0-4, kierunek – 0-poziomo, 1-
pionowo, rozmiar – wielkość określona numerycznie.
Zadania:
1. Program rysuje słońce, domek i samochód przed domkiem
2. Program wyświetla na ekranie samochodzik jeŜdŜący z lewej do prawej i z powrotem
3. Program wyświetla kółko poruszające się po ekranie po linii prostej i „odbijające” się od
krawędzi ekranu.