| | Jeżeli nie masz w czym programować to ściągnij:
Poniżej znajduje się kurs pascala dla początkujących
Objaśnienie Pojęć
Procedura - jest to w skrócie pewien wyraz, który po
wstawieniu do programu, coś nam wykona np. wyczyści ekran, narysuje
linię (sformatuje dysk :) itd.
Funkcja - jest to podobnie jak
procedura, pewien wyraz, który nie dość że coś wykona to również
zwróci nam rezultat tego co zrobił, przykładowymi funkcjami są:
pierwiastkowanie, sinus, cosinus. Zwracaną wartością
niekoniecznie musi być liczba może to być również inny
rodzaj zmiennych.
Słowo Kluczowe
- samo w sobie nie robi nic, ale w połączeniu z innymi pozwala nam na
grupowanie procedur i funkcji w jedną całość, używanie
pętli... a z resztą sami później zobaczycie to w praktyce ;-)
Stała - jest to pewna wartość
przypisana znakowi/wyrazowi której nie można zmienić np: stałej
PI jest przyporządkowana liczba 3.1415...
Zmienna - Jak sama nazwa
wskazuje zmienna jest to wyraz, któremu jest przypisana pewna wartość,
którą w czasie działania programu możemy swobodnie zmieniać
w zakresie danego typu.
Biblioteki (moduły)
- zapisane są w nich różne funkcje i procedury do użycia w
programie.
Najważniejsze Podstawowe
Typy Zmiennych
ˇ
TYPY CAŁKOWITE - są to wartości liczbowe,
które mieszczą się w podanych zakresach, im większy zakres to
automatycznie zwiększa się zapotrzebowanie liczby na pamięć,
podaję więc również ile bajtów dany typ liczby zajmuje w pamięci:
o SHORTINT (-128..127) 1 bajt
o INTEGER (-32768..32767} 2 bajty
o LONGINT {-2147483648..2147483647} 4 bajty
o BYTE {0..255} 1 bajt
o WORD {0..65535} 2 bajty
ˇ
TYP LOGICZNY - BOOLEAN - typ ten może przyjmować
jedynie dwie wartości: TRUE (prawda) lub FALSE (fałsz) dzięki
temu zajmuje on jedynie 1/8 bajta
ˇ
TYP ZNAKOWY - CHAR - typ ten przyjmuje dowolny
pojedynczy znak o kodach ASCII (0..255) np. znak "A" czy "!"
ˇ
TYP ŁAŃCUCHOWY - STRING - jest to ciąg o
długości 0-255 znaków, przykładowym łańcuchem jest:
'To jest tekst', zwróć uwagę na użyte apostrofy ! Jeżeli
jakiekolwiek znaki umieścisz pomiędzy apostrofami będzie to
uznawane wtedy za tekst nawet jeżeli znajdować się tam będą
w środku liczby !
Stosowanie Komentarzy
Komentarze w programie nie są niezbędne,
ale bardzo upraszczają późniejszą poprawę/modyfikację
programu i to dzięki komentarzom nasz program staje się bardziej
czytelny również dla innych osób. W Pascalu ujmuje się je pomiędzy
nawiasy klamrowe "{","}"
Stosowanie Wcięć
Wcięcia stosowane są do łatwiejszego
zorientowania się w programie źródłowym, dla programisty jest to
bardzo przydatne gdyż natychmiast widzi, które fragmenty programu są
ze sobą bardziej powiązane a które mniej.
Podstawowy Szkielet Programu
Podstawowy, a zarazem najmniejszy program w
Pascalu wygląda tak:
begin {1}
end. {2}
Przedstawione tutaj dwie linijki całkowicie nic nie robią,
informują one jedynie kompilator gdzie zaczyna się nasz główny
program {1} i gdzie kończy {2} pomiędzy tymi liniami będzie w
przyszłości znajdował się nasz program, zwróć uwagę
że {2} po "END" jest postawiona kropka, ponieważ
"END." oznacza koniec programu, a "END;" koniec fragmentu
programu !
Stałe deklaruje się
jeszcze przed głównym programem słowem kluczowym "Const", w
programie przykładowo wygląda to tak:
Const
abc=500;
l3='tu jest tekst';
sprawdz=TRUE;
begin
end.
Jak już pewnie zauważyłeś nawet w tak prostym programiku,
zastosowałem wcięcia dzięki
temu widzimy, które linie są liniami ze stałymi a które nie.
Zadeklarowałem tutaj trzy stałe: "abc" - przypisana została
do niej liczba 500, teraz jeżeli dalej w programie użyjemy stałej
"abc" będzie ona postrzegana przez kompilator jako liczba 500, można
ją dodawać, odejmować, wyświetlać itd. Stała
"l3" jest ciągiem znaków 'tu jest tekst', a "sprawdz"
jest postrzegane jako stała logiczna "PRAWDA"
Deklaracja Zmiennych
Zmienne deklaruje się
podobnie jak stałe jeszcze przed głównym programem, słowem
kluczowym "Var", w programie przykładowo wygląda to tak:
Var
abc:byte;
l3,linia,t:string; {1}
sprawdz:boolean;
begin
end.
Teraz zmienne zostały przypisane do danego typu
i ich wartość będzie można dowolnie zmieniać w zakresie
tego typu. Zwróć uwagę że pomiędzy nazwą zmiennej a
jej rodzajem, został użyty dwukropek zamiast znaku równości jak
to miało miejsce przy stałych. Możliwe jest definiowanie wielu
zmiennych tego samego typu w jednej linii, wystarczy je wtedy rozdzielić
przecinkami {1}. KAŻDA ZMIENNA PRZED UŻYCIEM W PROGRAMIE MUSI BYĆ
WCZEŚNIEJ ZADEKLAROWANA.,
Deklaracja Bibliotek (modułów)
Uses dos,crt;
begin
end.
Od tej pory program może używać funkcji i procedur zdefiniowanych
w modułach "DOS", "CRT" oraz mimo że nie
deklarowaliśmy, automatycznie ładowanego modułu
"SYSTEM".
Pewnie zwróciłeś uwagę na średnik
występujący na końcach niektórych linii, oznacza on zakończenie
procedury, funkcji, pętli czy instrukcji warunkowych. Średnika nie
stawia się po słowach kluczowych rozpoczynających pewien fragment
programu, dopiero stawia się go na końcu tego fragmentu ( pomiędzy
nimi mogą znajdować się jeszcze inne linie ) np.
"begin...end;"
Instrukcja Przypisania
Instrukcja przypisania, służy do nadawania zmiennym wartości,
wygląda ona tak: ":=" np. a:=b( przypisujemy zmiennej a wartość
zmiennej b)
zabezpieczający dalszy dostęp poprzez hasło.
Procedura Write
Służy do wypisania na ekran liczby/tekstu:
Const
jakas_stala=999;
Var
jakas_zmienna:Word;
Begin
jakas_zmienna:=448;
Write(123); {1}
Write('bzdura'); {2}
Write(4*8); {3}
Write('4*8'); {4}
Write(jakas_stala); {5}
Write(jakas_zmienna); {6}
Write(jakas_zmienna+12); {7}
Write(3/4); {8}
End.
Program wypisze na ekranie liczbę 123 {1}, tekst 'bzdura' {2},
wynik działania matematycznego 32 {3}, tekst '4*8' {4}, stałą o
wartości 999 {5}, zmienną do której została wprowadzona liczba
448 {6}, oraz tą samą zmienną powiększoną o 12 czyli
460 {7}.
W tym momencie pojawia się dziwna rzecz, w linii {8} zamiast spodziewanego
wyniku 0.75 wyświetla nam program liczbe 7.5000000000E-01 ale jest to nic
innego jak liczba przed literką E pomnożona o 10 do potęgi takiej
jaka się znajduje po literce E czyli 7.5000000000 * 10 -01 i
jest to dokładnie 0.75. Aby wynik wyświetlany był jednak w
bardziej czytelnej formie, do której jesteśmy na codzień
przyzwyczajeni wystarczy użyć zapisu formatującego wyświetlane
dane, a dokładniej to należy dodać dwie cyferki oddzielone od
siebie dwukropkami np:
Write(3/4:8:4);
Znaczy to: wyświetl liczbę ograniczając wyświetlanie
do 8 znaków przed kropką i 4 po kropce, dzięki temu otrzymamy łatwo
czytelny wynik 0.7500
Procedura WRITE nie wykonuje nic więcej oprócz wypisania wartości z
pomiędzy nawiasów dlatego wszystkie te wyświetlane wartości będą
znajdowały się jednej linii.
Można również podać wszystkie te parametry naraz, oddzielając
je przecinkami:
Const
jakas_stala=999;
Var
jakas_zmienna:Word;
Begin
jakas_zmienna:=448;
Write(123,'bzdura',4*8,'4*8',jakas_stala,jakas_zmienna,jakas_zmienna+12,3/4:8:2);
End.
Procedura WriteLn
Podobnie jak WRITE, WRITELN wypisuje wartość z pomiędzy
nawiasów, ale jeszcze dodatkowo po wypisaniu tej wartości przechodzi do
następnej linii.
Begin
WriteLn(123); {1}
WriteLn('bzdura'); {2}
WriteLn(''); {3}
WriteLn; {4}
WriteLn(4*8); {5}
End.
W tym przypadku w KOLEJNYCH LINIACH zostaną wyświetlone wartości:
liczba 123 {1} , tekst 'bzdura' {2}, pusty ciąg znaków '' {3} ( czyli
niczego nie wyświetli i przejdzie do następnej linii ), kolejną
pustą linię {4} ( po prostu procedura jest wykonywana podobnie jak w
{3} z pustym łańcuchem znaków ) i wynik działania 32 {5}.
Podobnie jak w procedurze Write parametry można podawać oddzielone
przecinkami:
Begin
WriteLn(123,'bzdura','',,4*8);
End.
Zwróć uwagę, że w tym przypadku jak pomineliśmy
pusty ciąg znaków i po poprostu wpisaliśmy kolejny przecinek (
podobnie jak w {4} ) kompilator wyrzuci nam błąd. Prawidłowym
zapisem natomiast jest:
Begin
WriteLn(123,'bzdura','','',4*8);
End.
Procedura Read
Pozwala na wprowadzenie do zmiennej wartość
podawaną z klawiatury w czasie działania programu:
Var
zm1:String;
zm2:Word;
Begin
Read(zm1); {1}
Read(zm2); {2}
Read; {3}
End.
Program czeka na wprowadzenie dwóch zmiennych, ZM1 typu
STRING {1} oraz ZM2 typu
WORD {2}, jeżeli natomiast wywołamy tą procedurę
bez żadnych parametrów {3} to program czeka w tym momencie na wciśniecie
klawisza Enter. W przypadku wprowadzania zmiennych trzeba uważać na
kilka rzeczy:
ˇ
Jeżeli program będzie oczekiwał liczby a
my podamy mu tekst, to zastanie on zatrzymany i wyświetli błąd
ˇ
Jeżeli czeka np. na liczbę typu WORD, a
podamy mu przekraczającą jej typ liczbę 70000, to w zmiennej
znajdzie się całkiem inna liczba której się tam niespodziewaliśmy
w tym przypadku będzie to 4464 będzie to tzw. przekręcenie
licznika :)
ˇ
Jeżeli czeka na typ STRING a podamy liczbę,
to uzna tą liczbę za tekst tak więc nie będzie można
jej używać np. w działaniach matematycznych. (Wprawdzie jest
funkcja przekształcająca liczbę umieszczoną w typie STRING
na WORD, INTEGER itd. ale opowiem o niej dopiero później, niemniej
istnieje taka i nazywa się VAL).
Procedura READ przyjmuje kolejne zmienne w tej samej linii jedna za drugą.
Procedura ReadLn
Podobnie jak READ procedura ta pozwala na
wprowadzenie do zmiennej wartość podawaną z klawiatury w czasie
działania programu, z tym, że po przyjęciu wartości program
przechodzi do następnej linii:
Var
imie:String;
Begin
Write( 'Jak masz na imie ? : ' ); {1}
ReadLn( imie ); {2}
WriteLn; {3}
WriteLn( 'Witaj ' , imie , '!' ); {4}
Write( 'Wcisnij Enter...' );
ReadLn; {5}
End.
Programik ten wypisuje tekst {1} i czeka na wprowadzenie zmiennej IMIE
{2}, następnie robi linijkę odstępu {3} i wypisuje tekst, zmienną
i znowu tekst {4}. Na sam koniec czeka dodatkowo na wciśniecie klawisza
Enter {5}.
Procedura GotoXY
Składnia: GotoXY(x,y:byte); [CRT]
Procedura ta pozwala na umieszczenie kursora (miejsca, od którego np. będą
wyświetlane wartości przez Write), w dowolnym miejscu ekranu,
procedura ta znajduje się w bibliotece CRT:
Uses CRT;
Begin
GotoXY(20,10);
Write('Ten tekst rozpoczyna się w 20 kolumnie i 10 wersie');
End.
W tym programie procedura GotoXY nakazuje przenieść kursor do
20 wiersza i 10 kolumny i wyświetlić tekst.
Procedura Halt
Przerywa ona natychmiast wykonywanie programu i
powraca do DOS-a
Procedura ClrScr
Składnia: ClrScr; [CRT]
Usuwa wszystkie znaki z ekranu tekstowego (czyści go) i ustawia kursor w
pozycji 0,0 (lewy górny róg ekranu)
Procedura Sound
Składnia: Sound(CZE:word); [CRT]
Włącza dźwięk o częstotliwości CZE ( liczba typu
word ) emitowany przez głośnik komputera. Z własnych praktyk
zauważyłem że dźwięk o częstotliwości 3160
jest "trochę" denerwujący :)
Procedura NoSound
Składnia: NoSound; [CRT]
Wyłącza dźwięk emitowany przez głośnik komputera,
włączony uprzednio przez SOUND.
Procedura Delay
Składnia: Delay(CZAS:word); [CRT]
Wstrzymuje program na określoną (zmienna CZAS) ilość
milisekund (1000 milisekund=sekunda), przydatne np. przy procedurze Sound
Uses CRT;
Begin
Sound(2000);
Delay(1000);
NoSound;
End.
Instrukcja Warunkowa IF ...
THEN ... [ELSE ...]
Instrukcja ta sprawdza czy jest spełniony
warunek postawiony po "IF", jeżeli tak to wykonywana jest
instrukcja po słowie "THEN". Można jeszcze po THEN "coś
tam", użyć słowa ELSE oznaczającego "w przeciwnym
wypadku", umieszczona po ELSE instrukcja zostanie wykonana dopiero wtedy,
gry warunek postawiony po "IF" NIE ZOSTAŁ SPEŁNIONY np:
Var
ttt:Byte;
Begin
Write('Podaj liczbę z zakresu 0..255 : ');
ReadLn(ttt);
IF ttt=40 THEN WriteLn('Podałeś liczbę 40'); {1}
IF ttt>100 THEN WriteLn('Podałeś liczbę większą niż 100') ELSE WriteLn('Podałeś liczbę równą lub mniejszą od 100'); {2}
End.
Ograniczę się w opisie programu tylko do rzeczy nowych, a więc:
{1} Instrukcja IF sprawdza czy wpisana liczba to 40, jeżeli tak to wypisuje
tekst, jeżeli nie, to omija instrukcję znajdującą się
po THEN i przechodzi do następnej linii. Zwróć uwagę na to
że przy porównywaniu używa się znaku "=" a przy
przypisywaniu znaku ":=".
{2} Instrukcja IF sprawdza czy wpisana liczba jest większa od 100 jeżeli
tak to wykonuje instrukcję po THEN i wypisuje tekst, jeżeli nie znaczy
to, że liczba jest mniejsza lub RÓWNA 100! i wtedy pomija instrukcję
po THEN ale widzi że jest jeszcze instrukcja ELSE i wykonuje wtedy to, co
po niej się znajduje. Gdyby liczba była większa niż 100, nie
wykonałby nic co znajdowałoby się po instrukcji ELSE !
Specjalnie używam tu tyle razy słowa "instrukcja" po to abyś
zapamiętał, że po instrukcjach, które nie kończą
fragmentu programu NIE STAWIA SIĘ ŚREDNIKA ! Program ten można
zapisać również w takiej postaci abyś widział że
faktycznie po IF, THEN, oraz ELSE nie ma tych nieszczęsnych średników.
(Rany ale zamotałem :-)
Var
ttt:Byte;
Begin
Write('Podaj liczbę z zakresu 0..255 : ');
ReadLn(ttt);
IF ttt=40 THEN {1}
WriteLn('Podałeś liczbę 40'); {1}
IF ttt>100 THEN {2}
WriteLn('Podałeś liczbę większą niż 100') ELSE {2}
WriteLn('Podałeś liczbę równą lub mniejszą od 100'); {2}
End.
Instrukcja Grupująca
Begin End
Instrukcję grupującą rozpoczyna słowo
kluczowe BEGIN, a kończy ją END. Wszystkie instrukcje umieszczone pomiędzy
tymi słowami będą traktowane jako jedna. Jest to przydatne np.
przy poznanej przez chwilą instrukcji warunkowej IF THEN ELSE np.
Uses CRT;
Var
strona:byte;
Begin
Write('1-strona tytulowa 0-koniec : ');
ReadLn(strona);
IF strona=1 THEN
Begin
ClrScr;
WriteLn('Program przykładowy w języku Turbo Pascal');
WriteLn('Autor: Robert Wróbel (GiGi)');
WriteLn('Napisany Dnia 20.09.97')
End;
End.
Jak widzisz po wpisaniu cyfry "1" zostanie wyczyszczony ekran
i pojawią się trzy linijki tekstu więc wykona cztery instrukcje
zamiast jednej, gdyby nie było BEGIN END to program by wyglądał
tak:
Uses CRT;
Var
strona:byte;
Begin
Write('1-strona tytulowa 0-koniec : ');
ReadLn(strona);
IF strona=1 THEN ClrScr;
IF strona=1 THEN WriteLn('Program przykładowy w języku Turbo Pascal');
IF strona=1 THEN WriteLn('Autor: Robert Wróbel (GiGi)');
IF strona=1 THEN WriteLn('Napisany Dnia 20.09.97')
End.
Jak widać, teraz jest "trochę" bardziej naśmiecone,
a co jeśli ma wykonać 50..100.. linijek ? Aż mi się włos
jeży na głowie jak pomyślę :-)
Pętla
REPEAT ... UNTIL ...
Jest to również w pewnym sensie instrukcja
grupująca i jest traktowana jak jedna instrukcja (podobnie jak
Begin...End). Pętla zaczyna się słowem kluczowym REPEAT dalej
znajdują się linie do wykonania a zakończona jest słowem
UNTIL i warunkiem, który jeżeli zostanie spełniony przerywa pętlę
i kontynuuje program, jeżeli nie, powraca na początek (po REPEAT) i
wykonuje instrukcje pomiędzy nimi po raz kolejny i znowu dochodzi do UNTIL,
znowu sprawdza warunek itd. jest to pętla która zostanie CO NAJMNIEJ RAZ
WYKONANA, gdyż warunek znajduje się dopiero na końcu (jest też
pętla WHILE .. DO .. w której warunek zostaje sprawdzany na początku)
Przykład:
Uses CRT;
Var
licz:byte;
Begin
ClrScr;
REPEAT
Write('Wpisz jakąś liczbę (0-wyjscie) : ');
ReadLn(licz);
WriteLn('Potega liczby ',licz,' to ',licz*licz);
WriteLn;
UNTIL licz=0;
End.
Program tak długo podaje potęgi kwadratowe wpisanych liczb póki
nie podamy mu cyfry 0, oczywiście te końcowe "0" również
spotęguje gdyż dopiero sprawdzi warunek na końcu pętli.
Ciekawą rzeczą którą można zrobić to pętla nieskończona,
sam zobacz dlaczego :)
Begin
REPEAT
UNTIL 1=2;
End.
Podsumowujący Lekcję
Program
Już właściwie możesz sam napisać ten obiecany
program na hasło i to na bardzo wiele sposobów, jeżeli czujesz się
na siłach, to spróbuj go zrobić nie korzystając na razie z następnego
podrozdziału jeżeli nawet się nie uda, to na pewno czegoś w
tym eksperymentowaniu się nauczysz, a jeżeli uda ci się go wykonać
to naprawdę gratuluję ! stałeś się programistą,
napisałeś swój pierwszy program korzystając z własnych możliwości
! Nawet jeżeli nie jesteś pewien swojej wiedzy to naprawdę zachęcam:
SPRÓBUJ ZANIM POWIESZ ŻE NIE UMIESZ !
I na koniec tej lekcji jedno z praw Murphiego: "Przekleństwa są
jedynym językiem doskonale znanym przez programistów z całego świata",
jeżeli nie wiesz o co chodzi to sam się niedługo przekonasz ;-)
Tego programu nie będę opisywał powinieneś sam już
wiedzieć co do czego służy.
Uses CRT;
Const
haslo='Pascal';
Var
wprowadz:String;
petla:byte;
Begin
REPEAT
ClrScr;
GotoXY(31,12);
Write('Podaj haslo : ');
ReadLn(wprowadz);
IF petla=4 THEN
REPEAT
ClrScr;
GotoXY(31,12);
Write('Access Denied !');
Sound(3160);
Delay(500);
Sound(3190);
Delay(500);
UNTIL 1=2;
petla:=petla+1;
UNTIL wprowadz=haslo;
{ Haslo poprawne, dalsza część programu }
End.
Na tej lekcji dowiesz się jak pisać własne procedury i co
to są tablice. Są to wystarczająco złożone rzeczy, aby
zajeły nam całą lekcję. Na rozruszanie kolejne prawo
Murphiego: "Programista jest ostatnią osobą, która chciałaby
używać własnego programu", No to zaczynajmy, niech moc będzie
z Tobą :))
Tworzenie Procedur
Powiedzmy że w wielu miejscach programu
potrzebujemy wyczyścić ekran i narysować identyczną ramkę:
Uses CRT;
Var
Numer:byte;
Begin
Write('1 - Ramka pierwsza 2 - Ramka druga :');
Read(numer);
If numer=1 Then
Begin
ClrScr;
Writeln('I-------------------------------------------I');
Writeln('I I');
Writeln('I I');
Writeln('I I');
Writeln('I-------------------------------------------I');
GotoXY(8,3);
Write('Oto Ramka 1');
End;
If numer=2 Then
Begin
ClrScr;
Writeln('I-------------------------------------------I');
Writeln('I I');
Writeln('I I');
Writeln('I I');
Writeln('I-------------------------------------------I');
GotoXY(8,3);
Write('Oto Ramka 2');
End;
End.
Jak widzisz część programu zawiera identyczne polecenia
czy jest więc sens pisać kilka razy to samo ? Właśnie wtedy
z pomocą przychodzą nam WŁASNE procedury. Procedury tworzy się
jeszcze tuż przed naszym głównym programem podobnie jak zmienne i stałe.
Deklaruje się ją tak:
PROCEDURE JakasTam;
Begin
{ Treść procedury }
End;
I od tego momentu nasz program posiada dodatkową procedurę o
nazwie "JakasTam" i jeżeli użyjemy jej nazwy gdzieś w
programie to zostanie wykonane to co jest jej treścią. Aby to pokazać
jaśniej wstawię do poprzedniego programu procedurę o nazwie
"Ramka" i sam będziesz mógł się przekonać co to
zmieniło.
Uses CRT;
Var
Numer:byte;
PROCEDURE Ramka;
Begin
ClrScr;
Writeln('I-------------------------------------------I');
Writeln('I I');
Writeln('I I');
Writeln('I I');
Writeln('I-------------------------------------------I');
GotoXY(8,3);
End;
Begin
Write('1 - Ramka pierwsza 2 - Ramka druga :');
Read(numer);
If numer=1 Then
Begin
Ramka;
Write('Oto Ramka 1');
End;
If numer=2 Then
Begin
Ramka;
Write('Oto Ramka 2');
End;
End.
Widzisz teraz różnicę ? 7 linijek zostało zastąpionych
jedną: "Ramka" !! Program jest teraz po pierwsze: bardziej
przejrzysty, po drugie: jest krótszy ( może przy wykorzystaniu procedury 2
razy tego nie widać, ale jeżeli wykonamy ją więcej powiedzmy
5..10...100... to jest to bardzo zauważalne ), i po trzecie chyba najważniejsze:
Jeżeli chcemy zmienić tą ramkę w programie bez procedury
musielibyśmy zmieniać ją wiele razy w każdym miejscu gdzie
by się znajdowała, a tutaj wystarczy w jednym miejscu i już
gotowe :)
Tworzenie Procedur z
Parametrami
Wyobraź sobie teraz, że masz taki
program, który będzie wypisywał kilka linijek tekstu zaczynających
się w różnych miejscach ekranu:
Uses CRT;
Begin
GotoXY(10,8);
Write('Linijka 1');
GotoXY(42,2);
Write('Linijka 2');
GotoXY(30,6);
Write('Linijka 3');
GotoXY(13,14);
Write('Linijka 4');
GotoXY(63,19);
Write('Linijka 5');
End.
Pokażę Ci teraz jak zrobić procedurę która będzie
przyjmować 3 zmienne, 2 będą typu BYTE i 1 typu STRING. Nazywać
się będzie WriteXY i będzie miała za zadanie wyświetlenie
tekstu bezpośrednio w wybranym miejscu ekranu ( połączenie GotoXY
i Write )
Uses CRT;
PROCEDURE WriteXY(x,y:byte; s:string);
Begin
GotoXY(x,y);
Write(s);
End;
Begin
WriteXY(10,8,'Linijka 1');
WriteXY(42,2,'Linijka 2');
WriteXY(30,6,'Linijka 3');
WriteXY(13,14,'Linijka 4');
WriteXY(63,19,'Linijka 5');
End.
Może zwróciłeś uwagę na to, że nie ma tutaj
definicji poprzez "Var" zmiennych X,Y i S. Zostały one natomiast
podane w nawiasie po procedurze i zadeklarowane automatycznie przy jej tworzeniu,
ważną rzeczą jest to że będą one dostępne
TYLKO w jej obrębie ! Od tego momentu procedura ta BĘDZIE WYMAGAĆ
tych parametrów ( dwóch typu Byte i jednego String oddzielonych przecinkami )
Tworzenie Tablic
Teraz będzie coś co jak wiem z doświadczenia
jest dla początkujących bardzo trudne do zrozumienia i może
doprowadzić do załamania nerwowego ;) więc poświęcę
temu trochę miejsca i opiszę chociaż same podstawy krok po kroku.
Zacznę od najprostszego przykładu. Program wczytuje 5 zmiennych i wyświetla
je w odwrotnej kolejności:
Var
a1,a2,a3,a4,a5:string;
Begin
ReadLn(a1);
ReadLn(a2);
ReadLn(a3);
ReadLn(a4);
ReadLn(a5);
WriteLn(a5);
WriteLn(a4);
WriteLn(a3);
WriteLn(a2);
WriteLn(a1);
End.
Jak widzisz to bardzo prosty prymitywny program, teraz spróbuję
wyjaśnić jak używać tablic, a coś mi się zdaje
że będzie ciężko :(
Załóżmy teraz takie coś ( poniższe 2 linijki działać
nie będą ! są napisane tylko na potrzeby wytłumaczenia )
że posiadasz zmienne podobnie jak w programie powyżej ale nazywają
się:
Var
a[1],a[2],a[3],a[4],a[5]:string;
A tak naprawdę to jest JEDNA zmienna tablicowa nazywająca się
"a" poprawna deklaracja takiej zmiennej to:
Var
a:array[1..5]of string;
i oznacza to: zadeklaruj zmienną "a" która będzie
posiadać elementy ponumerowane od 1 do 5 i będą one typu String,
będą więc to kolejno: a[1], a[2], a[3], a[4], a[5] tak więc
program teraz będzie wyglądał tak:
Var
a:array[1..5] of string;
Begin
ReadLn(a[1]);
ReadLn(a[2]);
ReadLn(a[3]);
ReadLn(a[4]);
ReadLn(a[5]);
WriteLn(a[5]);
WriteLn(a[4]);
WriteLn(a[3]);
WriteLn(a[2]);
WriteLn(a[1]);
End.
Do tej pory niewiele się więc zmieniło, zmienne zostały
po prostu zastąpione na takie co się tylko inaczej zapisuje. Na razie
powinno być wszystko jasne. Teraz trochę zagmatwam ( nadal
rozpatrujemy ten sam program )
Var
a:array[1..5] of string;
kolejna:byte;
Begin
kolejna:=1;
ReadLn(a[kolejna]);
kolejna:=2;
ReadLn(a[kolejna]);
kolejna:=3;
ReadLn(a[kolejna]);
kolejna:=4;
ReadLn(a[kolejna]);
kolejna:=5;
ReadLn(a[kolejna]);
kolejna:=5;
WriteLn(a[kolejna]);
kolejna:=4;
WriteLn(a[kolejna]);
kolejna:=3;
WriteLn(a[kolejna]);
kolejna:=2;
WriteLn(a[kolejna]);
kolejna:=1;
WriteLn(a[kolejna]);
End.
W tym momencie już pewnie jesteś zakręcony :) ale zobacz
do czego doszliśmy ( ten program wykonuje dokładnie to samo co ten na
początku ), dokonaliśmy takiego czegoś że mimo że występują
te same linijki przy wpisywaniu i wyświetlaniu zmiennych to jednak zawartość
tych zmiennych zmienia się tak samo jak w poprzednich programach !!
Dokonaliśmy tego używając zmiennej tablicowej, to właśnie
przez zmieniającą się zmienną "kolejna" zmienia się
"a" ! Zobacz teraz jak wygląda końcowa wersja tego programu
( przepisz go sobie na kartkę albo wydrukuj bo zaraz będziemy go
analizować) :
Var
a:array[1..5] of string;
kolejna:byte;
Begin
kolejna:=0; {1}
Repeat {2}
kolejna:=kolejna+1; {3}
ReadLn(a[kolejna]); {4}
Until kolejna=5; {5}
Repeat {6}
WriteLn(a[kolejna]); {7}
kolejna:=kolejna-1; {8}
Until kolejna=0; {9}
End.
Zobacz jak nam się drastycznie skrócił
program ! ( jak poznasz później jeszcze parę poleceń to program
ten będziesz mógł zmieścić w 2 ( dosłownie dwóch )
linijkach ! Ale to tak na marginesie :) Przeanalizujmy go teraz krok po kroku (
jeżeli jeszcze nie rozumiesz i teraz nie zaskoczysz to klops, bo nie wiem
czy da się to jeszcze prościej wytłumaczyć tak więc
skup się :)
1. w linii {1} nadajemy zmiennej "kolejna" wartość
"0"
2. w linii {2} rozpoczynamy pętlę
3. w linii {3} zwiększamy wartość zmiennej "kolejna" o
"1" ma teraz wartość "1"
4. w linii {4} ponieważ "kolejna" jest równa "1"
wprowadzamy zmienną "a[1]"
5. w linii {5} sprawdzamy czy "kolejna" jest równa 5, ponieważ
nie powracamy do linii {3}
6. w linii {3} znowu zwiększamy "kolejna", ma teraz wartość
2
7. w linii {4} ponieważ "kolejna" jest równa "2"
wprowadzamy zmienną "a[2]"
8. w linii {5} sprawdzamy czy "kolejna" jest równa 5, ponieważ
nie powracamy do linii {3}
9. w linii {3} znowu zwiększamy "kolejna", ma teraz wartość
3
10. w linii {4} ponieważ "kolejna" jest równa "3"
wprowadzamy zmienną "a[3]"
I tak dalej aż "kolejna" osiągnie wartość
"5"
11. w linii {6} rozpoczynamy kolejną pętlę, a ponieważ teraz
chcemy wyświetlać od końca ( od 5 do 1 ) to nie musimy wstawiać
liczby do zmiennej "kolejna" bo wiemy jaka tam się znajduje, właśnie
owe "5"
12. w linii {7} ponieważ "kolejna=5" wyświetla zmienną
"a[5]"
13. w linii {8} zmniejszamy wartość zmiennej "kolejna" o
"1" ma teraz wartość "4"
14. w linii {9} sprawdzamy czy "kolejna" ma wartość
"0" jak nie to wracamy do linii {7}
15. w linii {7} ponieważ "kolejna=4" wyświetla zmienną
"a[4]"
16. w linii {8} zmniejszamy wartość zmiennej "kolejna" o
"1" ma teraz wartość "3"
17. w linii {9} sprawdzamy czy "kolejna" ma wartość
"0" jak nie to wracamy do linii {7}
18. w linii {7} ponieważ "kolejna=3" wyświetla zmienną
"a[3]"
I tak dalej aż "kolejna" osiągnie wartość
"0" wtedy następuje koniec programu.
Teraz na waszym miejscu zastanowiłbym się "a po cholerę mi
tyle kłopotów dla tak prostego programu ?" Odpowiedź nie jest
prosta ale zobacz jedną rzecz: Aby zwiększyć o jedną zmienną
pierwotny program należy dopisać dwie dodatkowe linijki a w końcowym
zmienić tylko parę wartości ( dokładnie tylko dwie
"5" na "6", a ilość linii pozostaje bez zmian ), a
gdy potrzebujesz zwiększyć o 50 zmiennych ? Pierwotny program rośnie
o 100 linijek, a końcowy pozostaje nadal z taką samą ilością
! To nie jest jedyna zaleta stosowania tablic, dzięki nim można
sortować dane,
Na tej lekcji dowiesz się jak zmieniać kolory w trybie
tekstowym, poznasz jakie są operacje logiczne i po co one nam, oraz jak
zapisać na dysk plik z tekstem i jak go później wczytać.
Prowadzić to będzie do tematu tej lekcji: prostej bazy danych -
ulubionego tematu znęcających się na studentach profesorów :)
Procedura TextColor
Składnia:
TextColor(kolor:byte); CRT
Zmienia kolor wyświetlania tekstu, możliwe do wybrania jest 16 kolorów:
Black = 0 - czarny
Blue = 1 - niebieski
Green = 2 - zielony
Cyan = 3 - turkusowy
Red = 4 - czerwony
Magenta = 5 - karmazynowy
Brown = 6 - brązowy
LightGray = 7 - jasnoszary
DarkGray = 8 - ciemnoszary
LightBlue = 9 - jasnoniebieski
LightGreen = 10 - jasnozielony
LightCyan = 11 - jasnoturkusowy
LightRed = 12 - jasnoczerwony
LightMagenta = 13 - jasnokarmazynowy
Yellow = 14 - żółty
White = 15 - biały
Można wykonać również kolor migoczący, uzyskuje się
poprzez dodanie do wybranego koloru liczby 128 ( Blink ) np.
Uses CRT;
Begin
TextColor(Blue);
Write('Napis Niebieski');
TextColor(8);
Write('Napis Ciemnoszary');
TextColor(Red+Blink);
Write('Napis Czerwony mrugajacy');
TextColor(15+128); { TextColor(143); }
Write('Napis Biały mrugający');
End.
Procedura TextBackGround
Składnia:
TextBackGround(kolor:byte); CRT
Zmienia kolor tła wyświetlanego tekstu, możliwe do wybrania jest
8 kolorów:
Black = 0 - czarny
Blue = 1 - niebieski
Green = 2 - zielony
Cyan = 3 - turkusowy
Red = 4 - czerwony
Magenta = 5 - karmazynowy
Brown = 6 - brązowy
LightGray = 7 - jasnoszary
Przykład:
Uses CRT;
Begin
TextBackGround(Blue);
Write('Napis na niebieskim tle');
TextBackGround(4);
Write('Napis na czerwonym tle');
End.
Aby zmienić kolor podkładu dla całego ekranu należy
wykonać tą procedurę i wyczyścić ekran np.
Uses CRT;
Begin
TextBackGround(Green);
ClrScr;
Write('Oto napis na całym zielonym ekranie :)');
End.
Operator AND
Mówiąc po polsku jest to operator
"I" i stosuje się tam gdzie są potrzebne spełnione dwa
lub więcej warunków np. w IF..THEN.. albo w pętli REPEAT..UNTIL,
warunki muszą być podane w nawiasach np.
Var
a1,a2,a3:byte;
Begin
Write('Podaj 1 liczbe : ');
ReadLn(a1);
Write('Podaj 2 liczbe : ');
ReadLn(a2);
Write('Podaj 3 liczbe : ');
ReadLn(a3);
If (a1>a2) AND (a1>a3) Then WriteLn('Liczba ',a1,' jest najwieksza z podanych');
If (a2>a1) AND (a2>a3) Then WriteLn('Liczba ',a2,' jest najwieksza z podanych');
If (a3>a1) AND (a3>a2) Then WriteLn('Liczba ',a3,' jest najwieksza z podanych');
End.
Program sprawdza która z podanych trzech liczb jest największa i
wyświetla ją na ekranie.
Operator OR
Zanim dalej zaczniesz czytać, zaznajom się
z nieopisaną wcześniej funkcją:
ReadKey
Mówiąc po polsku jest to operator "LUB" i stosuje się tam
gdzie jest potrzebny spełniony co najmniej jeden z dwóch lub więcej
warunków, stosuje się go np. w IF..THEN.. albo w pętli REPEAT..UNTIL,
warunki te muszą być podane w nawiasach np.
Uses CRT;
Var
c:char;
Begin
Write('Czy na pewno ? (T/N) :');
Repeat
c:=ReadKey;
Until (c='t') or (c='n');
End.
Program ten czeka na wciśnięcie klawisza "t" lub
"n", ale jest niedoskonały ponieważ gdy wciśniemy duży
klawisz "T" lub "N" to wtedy nie zadziała. Rozwiązaniem
tego jest dodanie obsługi tych klawiszy, poprawiony program wygląda więc
tak:
Uses CRT;
Var
c:char;
Begin
Write('Czy na pewno ? (T/N) :');
Repeat
c:=ReadKey;
Until (c='t') or (c='T') or (c='n') or (c='N');
End.
Funkcja UpCase
Składnia: duza:=UpCase(literka:char):char;
Funkcja zamienia małą literkę na dużą, w przypadku
podania już dużej litery lub cyfry nie następuje zamiana. np:
UpCase('a') = 'A', UpCase('B') = 'B', UpCase('6') = '6'. Tak więc program z
opisanego operatora OR można zapisać tak:
Uses CRT;
Var
c:char;
Begin
Write('Czy na pewno ? (T/N) :');
Repeat
c:=UpCase(ReadKey); {1}
Until (c='T') or (c='N'); {2}
End.
{1} Po wciśnięciu jakiegokolwiek znaku jest on zamieniany na
dużą literę i podstawiany do zmiennej C
{2} Sprawdzenie czy zmienna C zawiera dużą literę T lub N
Procedura Assign
Składnia: Assign(var Plik:text;
nazwapliku:string);
Procedura kojarzy identyfikator "Plik" z plikiem dyskowym o nazwie
"nazwapliku" w której może mieścić się jeszcze
ścieżka dostępu. Bardziej jasne stanie to się przy następnych
procedurach "Reset" i "Rewrite".
Procedura Close
Składnia: Close(var Plik:text);
Zamyka plik otwarty uprzednio przez "Reset", "Append" lub
"Rewrite". Zaraz zobaczysz jak to się stosuje.
Procedura Reset
Składnia: Reset(var Plik:text);
Otwiera plik "Plik" skojarzony uprzednio przez "Assign". Od
tego momentu poprzez identyfikator "Plik" będzie można czytać
dane poprzez Read i ReadLn z dysku np.
Var
przyklad:text; {1}
linia:string;
Begin
Assign(przyklad,'C:\AUTOEXEC.BAT'); {2}
Reset(przyklad); {3}
ReadLn(przyklad,linia); {4}
WriteLn(linia); {5}
Close(przyklad); {6}
End.
Program otwiera plik "C:\AUTOEXEC.BAT" i wyświetla z
niego pierwszą linię. W kolejnych linijkach program wykonuje:
{1} Deklarujemy zmienną "przyklad" jako typ TEXT (plik textowy)
{2} Kojarzymy zmienną "przyklad" z plikiem
"C:\AUTOEXEC.BAT"
{3} Otwieramy plik "przyklad" do odczytu
{4} Wczytujemy kolejną linię ( ponieważ nie czytaliśmy z
niego wcześniej czyta pierwszą ) z pliku "przyklad" i
wstawiamy ją do zmiennej "linia" typu String
{5} Wyświetlamy zmienną "linia"
{6} Zamykamy plik
Funkcja EOF
Składnia: EOF(var Plik:text):boolean
Jest to funkcja zwracająca dwie wartości: prawdę (TRUE) lub fałsz
(FALSE) i określa czy plik "PLIK" znajduje się w pozycji końcowej
( FALSE - są w nim jeszcze jakieś nieprzeczytane dane, TRUE - tak to
koniec pliku nic więcej w nim nie ma ). np:
Var
przyklad:text;
linia:string;
Begin
Assign(przyklad,'C:\AUTOEXEC.BAT');
Reset(przyklad);
REPEAT {1}
ReadLn(przyklad,linia); {2}
WriteLn(linia); {3}
UNTIL EOF(przyklad); {4}
Close(przyklad);
End.
Program podobnie jak poprzednio otwiera plik ale odczytuje z niego
wszystkie linie zaczynając od pierwszej a kończąc na ostatniej.
{1} zacznij pętlę
{2} odczytaj kolejną linię z pliku "przyklad"
{3} wyświetl ją na ekranie
{4} sprawdź czy to już koniec pliku, jeśli nie to powróć do
{2} i wyświetl kolejną linię, a jeśli tak to opuść
pętlę.
Procedura Rewrite
Składnia: Rewrite(var Plik:text);
Procedura ta tworzy nowy plik o nazwie skojarzonej ze zmienną "Plik"
i udostępnia go do zapisu w nim danych ( poprzez Write i WriteLn ). UWAGA !
Jeżeli użyjesz tej procedury na istniejącym już pliku
zostanie on usunięty i na jego miejsce utworzony nowy np.
Var
przyklad:text; {1}
Begin
Assign(przyklad,'C:\PLIKTEST.TXT'); {2}
Rewrite(przyklad); {3}
WriteLn(przyklad,'Taki sobie głupi napis zapiszemy w pliku :)'); {4}
Close(przyklad); {5}
End.
{1} definiujemy zmienną "przyklad" jako typ TEXT
{2} kojarzymy zmienną "przyklad" z plikiem "C:\PLIKTEST.TXT"
ale nie musi on wcale istnieć ponieważ:
{3} tworzymy plik i otwieramy go do zapisu
{4} wpisujemy do pliku linię z tekstem
{5} zamykamy plik
UWAGA ! Jeżeli nie zamkniesz pliku i opuścisz program to jakiś
fragment ostatnio zapisywanych danych ulegnie skasowaniu !!!!! Czasami może
się zdarzyć że plik nie został do końca zapisany więc
w pierwszej kolejności sprawdź czy został on prawidłowo
zamknięty !
Napiszemy sobie prostą bazę osobową
czyli wystarczy: imię, nazwisko i telefon. Zaczniemy pisanie krok po kroku
od podstaw, tak abyś wiedział skąd i dlaczego się biorą
te dziwne rzeczy, a potem z czasem będziemy ją modyfikować.
Oki zrobimy najpierw program na jedną osobę tak aby ją można
wprowadzić i wyświetlić:
Uses CRT;
Var
Imie,nazwisko,telefon:string;
c,c2:char;
PROCEDURE Wprowadz;
Begin
ClrScr;
Write('Imie : ');
ReadLn(imie);
Write('Nazwisko : ');
ReadLn(nazwisko);
Write('Telefon : ');
ReadLn(telefon);
End;
PROCEDURE Wyswietl;
Begin
ClrScr;
WriteLn('Imie : ',imie);
WriteLn('Nazwisko : ',nazwisko);
WriteLn('Telefon : ',telefon);
WriteLn;
Write('Wcisnij jakis klawisz...');
c2:=readkey;
End;
Begin
Repeat
ClrScr;
Write('1. Nowy wpis 2. Wyswietlenie wpisu 3.Koniec programu : ');
Repeat
c:=readkey;
Until (c='1') OR (c='2') OR (c='3');
If c='1' Then Wprowadz;
If c='2' Then Wyswietl;
Until c='3';
End.
To już powinieneś rozumieć więc nie będę tłumaczył
prosty program do wprowadzenia i wyświetlenia tylko 3 zmiennych, tylko co
to za baza danych na jedną osobę ? Właśnie teraz przychodzą
nam z pomocą tablice które tak wałkowałem na poprzedniej lekcji
zobacz teraz jak zmienił się nasz program:
Uses CRT;
Var
Imie,nazwisko,telefon:array[1..30] of string; {1}
c,c2:char;
iloscosob:byte; {2}
t1:byte; {3}
PROCEDURE Wprowadz;
Begin
ClrScr;
Iloscosob:=iloscosob+1; {4}
Write('Imie : ');
ReadLn( imie[iloscosob] ); {5}
Write('Nazwisko : ');
ReadLn( nazwisko[iloscosob] ); {6}
Write('Telefon : ');
ReadLn( telefon[iloscosob] ); {7}
End;
PROCEDURE Wyswietl;
Begin
ClrScr;
Write('Numer wpisu ? (1..', iloscosob ,') :'); {8}
ReadLn(t1); {9}
WriteLn('Imie : ',imie[t1] ); {10}
WriteLn('Nazwisko : ',nazwisko[t1] ); {11}
WriteLn('Telefon : ',telefon[t1] ); {12}
WriteLn;
Write('Wcisnij jakis klawisz...');
c2:=readkey;
End;
Begin
Iloscosob:=0; {13}
Repeat
ClrScr;
Write('1. Nowy wpis 2. Wyswietlenie wpisu 3.Koniec programu : ');
Repeat
c:=readkey;
Until (c='1') OR (c='2') OR (c='3');
If c='1' Then Wprowadz;
If c='2' Then Wyswietl;
Until c='3';
End.
Jak widzisz linijek doszło niewiele a ilość wpisów zwiększona
została do 30. Teraz opiszę co się zmieniło:
Deklaracje:
{1} zmodyfikowałem 3 zmienne z pojedynczych na tablice
{2} dodałem zmienną "iloscosob" określającą
ile mamy wpisów w bazie
{3} dodałem zmienną pomocniczą "t1" która będzie
nam później na moment potrzebna
Główny program:
{13} wyzerowałem zmienną "iloscosob" ponieważ nie mamy
jeszcze żadnego wpisu
Procedury:
{4} ponieważ procedura ma za zadanie dopisywanie nowych danych musimy zwiększyć
zmienną "iloscosob" będącą równocześnie ilością
wpisów w bazie o jeden
{5} {6} {7} wprowadzenie danych do zmiennych tablicowych do elementów o numerze
"iloscosob"
{8} wyświetlenie informacji o ilości dostępnych do uzyskania
danych
{9} wprowadzenie zmiennej pomocniczej będącej numerem rekordu danych
do wyświetlenia
{10} {11} {12} wyświetlenie danych z tablic o elementach numer
"t1"
Do tamtego programu dodamy jeszcze teraz dwie procedury do zapisu i odczytu z
dysku, dwie procedury w tym listingu wyciąłem, aby nie przeszkadzały
w studiowaniu zmian w programie ale oczywiście muszą się one tam
znajdować :
Uses CRT;
Var
Imie,nazwisko,telefon:array[1..30] of string;
c,c2:char;
iloscosob:byte;
t1:byte;
plik:text; {1}
PROCEDURE Wprowadz; { taka jak poprzednio }
[...]
PROCEDURE Wyswietl; { taka jak poprzednio }
[...]
PROCEDURE Zapisz; {2}
Begin
Assign(plik,'BAZA.DAN'); {3}
ReWrite(plik); {4}
WriteLn(plik,iloscosob); {5}
t1:=0; {6}
Repeat
t1:=t1+1; {7}
WriteLn(plik,imie[t1] ); {8}
WriteLn(plik,nazwisko[t1] ); {9}
WriteLn(plik,telefon[t1] ); {10}
Until t1=iloscosob; {11}
Close(plik); {12}
End;
PROCEDURE Czytaj; {13}
Begin
Assign(plik,'BAZA.DAN'); {14}
Reset(plik); {15}
ReadLn(plik,iloscosob); {16}
t1:=0; {17}
Repeat
t1:=t1+1; {18}
ReadLn(plik,imie[t1] ); {19}
ReadLn(plik,nazwisko[t1] ); {20}
ReadLn(plik,telefon[t1] ); {21}
Until t1=iloscosob; {22}
Close(plik); {23}
End;
Begin
Iloscosob:=0;
Repeat
ClrScr;
WriteLn('1. Nowy wpis'); {24}
WriteLn('2. Wyswietlenie wpisu'); {25}
WriteLn('3. Odczyt z pliku'); {26}
WriteLn('4. Zapis do pliku'); {27}
WriteLn('5. Koniec programu'); {28}
Repeat
c:=
;
Until (c>='1') AND (c<='5'); {29}
If c='1' Then Wprowadz;
If c='2' Then Wyswietl;
If c='3' Then Czytaj; {30}
If c='4' Then Zapisz; {31}
Until c='5'; {32}
End.
{1} Definiujemy zmienną PLIK jako typ TEXT
{2} Tworzymy nową procedurę ZAPISZ która będzie odpowiedzialna
za zapis utworzonej bazy na dysku
{3-4} Otwieramy do zapisu plik o nazwie 'BAZA.DAN'
{5} Zapisujemy ilość wpisów na dysku
{6} Zerujmy zmienną pomocniczą T1 będzie ona potrzebna do
odliczania ilości zapisanych wpisów
{7} Zwiększamy zmienną T1 o jeden
{8-10} Zapisujemy IMIE NAZWISKO i TELEFON osoby numer T1
{11} Jeżeli zapisane zostało już "ILOSCOSOB" wpisów (
tzn. wszystkie ) to przejdź dalej jeśli nie wróć do {18}
{12} Zamykamy plik, gdybyśmy tego nie zrobili to stracilibyśmy część
danych
{13} Tworzymy nową procedurę CZYTAJ która będzie odpowiedzialna
za odczytanie bazy z dysku
{14-15} Otwieramy do odczytu plik o nazwie 'BAZA.DAN'
{16} Odczytujemy pierwszą linię będącą liczbą z
informacją o ilości wpisów
{17} Zerujmy zmienną pomocniczą T1 będzie ona potrzebna do
odliczania ilości odczytanych wpisów
{18} Zwiększamy zmienną T1 o jeden
{19-21} Odczytujemy IMIE NAZWISKO i TELEFON osoby numer T1
{22} Jeżeli odczytane zostało już "ILOSCOSOB" wpisów (
tzn. wszystkie ) to przejdź dalej jeśli nie wróć do {7}
{23} Zamykamy plik
{24-28} Nowe ulepszone menu :)
{29} Czekaj na wciśnięcie 1,2,3,4 lub 5
{30-31} Wywołaj nowe funkcje ( odczyt i zapis )
{32} Jeżeli wciśnięty został klawisz 5 to opuść
program
I oto mamy najprostszą bazę danych, teraz możesz ją już
udoskonalać, proponuję takie rzeczy:
ˇ
przy wyświetlaniu danych dodać obsługę
klawiszy do wyświetlania następnego/poprzedniego/pierwszego/ostatniego
wpisu
ˇ
opcję: nowa baza danych
ˇ
możliwość zmiany nazwy zapisywanego i
odczytywanego pliku
ˇ
zabezpieczenie przed wyświetleniem wpisu nr X jeżeli
taki nie istnieje
Pętla FOR...TO...DO...
Składnia: FOR zmienna:= liczba1 TO liczba2
DO ...
Jest to taka pętelka która wykonuje się określoną ilość
razy, no i eeeee... kurcze nie wiem jak do dokładniej opisać nie
mieszając za bardzo :) zaczniemy więc od przykładu, dwa programy
które wykonują to samo, pierwszy wykorzystujący dotychczas poznane
rzeczy :
Var
t:word;
BEGIN
t:=0;
repeat
t:=t+1;
writeln('petelka :)');
until t=15;
END.
a drugi z wykorzystaniem FOR..TO..DO.. :
Var
t:word;
BEGIN
FOR t:=1 TO 15 DO WriteLn('petelka :)');
END.
O widzisz jaka fajna pętelka ? 6 linii zastąpiliśmy
1 ! A chodziło nam o to by program wyświetlił 15 razy tekst
'petelka :)' a kolejne kawałki to :
FOR - Licz
t:= - używając zmiennej t
1 - od 1
TO - do
15 - 15
DO - wykonując
WriteLn('petelka :)'); - wyświetl tekst
Komputer napotykając na takie coś przy kolejnych przejściach
robi:
1. Jeżeli to 1 przejście to do zmiennej "t" wstawia liczbę
1, jeżeli kolejne to zwiększa zmienną "t" o 1
2. Wyświetla tekst
3. Sprawdza czy "t=15" jeżeli tak to przerywa pętle, jak nie
wraca do 1.
Powinieneś to zrozumieć, w sumie nie ma tu nic skomplikowanego, zobacz
teraz:
Var
t:word;
BEGIN
FOR t:=6 TO 23 DO WriteLn( t );
END.
Programik wyświetlił liczby od 6 do 23 ( wyświetlał
przy każdym przejściu wartość zmiennej "t" ). A
zobacz teraz:
Var
t:word;
BEGIN
FOR t:=23 DOWNTO 6 DO WriteLn( t );
END.
O co się stało ? Wyświetlił teraz w odwrotnej
kolejności ? A to właśnie dzięki temu że "TO"
zostało zastąpione przez "DOWNTO" i teraz znaczy mniej więcej:
Licz od 23 W DÓŁ do 6 i wyświetlaj zawartość zmiennej
!! I jeszcze jedna rzecz o której bym zapomniał: zmienna "t"
MUSI być typu porządkowego czyli BYTE, WORD, LONGINT oraz: INTEGER ( a
oznacza to że można używać liczb ujemnych ):
Var
t:integer; { UWAGA TUTAJ JEST ISTOTNA ZMIANA ! }
BEGIN
FOR t:=-4 TO 8 DO WriteLn( t );
END.
A może wyświetlilibyśmy sobie tabliczkę mnożenia
? Wykonamy taką prostą do 4 x 4, najpierw jedna linia:
Uses DOS,CRT;
Var
t:word;
Begin
ClrScr;
FOR t:=1 to 4 do
Begin
GotoXY(t*4,1); {1}
Write(t);
End;
End.
{1} Kursor umieszczamy przy kolejnych przejściach w kolumnach: 4
(1*4), 8 (2*4), 12 (3*4) i 16 (4*4) ( czyli dokładnie w miejscu t*4 ) oraz
wierszu 1 i wyświetla zmienną, tylko po co nam tylko jedna linia ?
Wykonamy więc teraz tzw. pętlę zagnieżdżoną:
Uses DOS,CRT;
Var
t,n:word;
Begin
ClrScr;
FOR n:=1 to 4 do {1}
FOR t:=1 to 4 do
Begin
GotoXY(t*4,n); {2}
Write(t*n); {3}
End;
End.
ajajajaj ale się nakomplikowało :)) doszła linia {1} -
dodatkowa pętla i teraz zmienne "n" i "t" przy
kolejnych przejściach wynoszą:
n=1 t=1
n=1 t=2
n=1 t=3
n=1 t=4
n=2 t=1
n=2 t=2
n=2 t=3
n=2 t=4
n=3 t=1
n=3 t=2
n=3 t=3
n=3 t=4
n=4 t=1
n=4 t=2
n=4 t=3
n=4 t=4
Tak więc: "t" jest zwiększane o "1" aż osiągnie
wartość 4 wtedy "n" jest zwiększane o "1" a
"t" wraca do wartości początkowej ( w tym wypadku do 1 ) i
tak cały czas aż obie zmienne osiągną końcowe wartości.
{2} - Kursor jest przemieszczany do miejsca ( T*4 , N )
{3} - Wyświetla mnożenie. Kolejno: 1,2,3,4 (t*1) 2,4,6,8 (t*2)
3,6,9,12 (t*3) 4,8,12,16 (t*4)
To są właśnie pętelki zagnieżdżone ( jedna w
drugiej ) w tym przypadku są to tylko dwie, ale jeżeli potrzebujemy to
możemy użyć trzy (potrzebne jako np.: X,Y i Z w przestrzeni 3D),
cztery, pięć albo i więcej. Ale nie będę już
bardziej Cię teraz tym męczył, na razie starczy :)
Funkcja Keypressed
Składnia: Keypressed:boolean; biblioteka: CRT
Funkcja sprawdza czy w chwili aktualnej jest wciśnięty jakiś
klawisz, i jeżeli tak zwraca wartość TRUE, jeżeli nie to
FALSE. np.
Uses CRT;
Var
klawisz:boolean;
Begin
klawisz:=Keypressed;
WriteLn(klawisz);
End.
Programik podstawia do zmiennej wartość "czy jakiś
klawisz został wciśnięty", a następnie ją wyświetla.
Ale skoro jest to funkcja to można skrócić program i wyświetlać
jej wartość od razu za pomocą Write ( program wykonuje się w
ciągu ułamka sekundy i właściwie ciężko uzyskać
aby pojawił się napis TRUE ale zaraz zobaczysz jak sensownie użyć
tej funkcji ).
Uses CRT;
Begin
WriteLn(Keypressed);
End.
A teraz zobacz jak ja najczęściej wykorzystuję tą
funkcję w swoich programach:
Uses CRT;
Begin
Repeat Until Keypressed; {1}
End.
Pętla FOR...TO...DO...
Składnia: FOR zmienna:= liczba1 TO liczba2
DO ...
Jest to taka pętelka która wykonuje się określoną ilość
razy, no i eeeee... kurcze nie wiem jak do dokładniej opisać nie
mieszając za bardzo :) zaczniemy więc od przykładu, dwa programy
które wykonują to samo, pierwszy wykorzystujący dotychczas poznane
rzeczy :
Var
t:word;
BEGIN
t:=0;
repeat
t:=t+1;
writeln('petelka :)');
until t=15;
END.
a drugi z wykorzystaniem FOR..TO..DO.. :
Var
t:word;
BEGIN
FOR t:=1 TO 15 DO WriteLn('petelka :)');
END.
O widzisz jaka fajna pętelka ? 6 linii zastąpiliśmy
1 ! A chodziło nam o to by program wyświetlił 15 razy tekst
'petelka :)' a kolejne kawałki to :
FOR - Licz
t:= - używając zmiennej t
1 - od 1
TO - do
15 - 15
DO - wykonując
WriteLn('petelka :)'); - wyświetl tekst
Komputer napotykając na takie coś przy kolejnych przejściach
robi:
1. Jeżeli to 1 przejście to do zmiennej "t" wstawia liczbę
1, jeżeli kolejne to zwiększa zmienną "t" o 1
2. Wyświetla tekst
3. Sprawdza czy "t=15" jeżeli tak to przerywa pętle, jak nie
wraca do 1.
Powinieneś to zrozumieć, w sumie nie ma tu nic skomplikowanego, zobacz
teraz:
Var
t:word;
BEGIN
FOR t:=6 TO 23 DO WriteLn( t );
END.
Programik wyświetlił liczby od 6 do 23 ( wyświetlał
przy każdym przejściu wartość zmiennej "t" ). A
zobacz teraz:
Var
t:word;
BEGIN
FOR t:=23 DOWNTO 6 DO WriteLn( t );
END.
O co się stało ? Wyświetlił teraz w odwrotnej
kolejności ? A to właśnie dzięki temu że "TO"
zostało zastąpione przez "DOWNTO" i teraz znaczy mniej więcej:
Licz od 23 W DÓŁ do 6 i wyświetlaj zawartość zmiennej
!! I jeszcze jedna rzecz o której bym zapomniał: zmienna "t"
MUSI być typu porządkowego czyli BYTE, WORD, LONGINT oraz: INTEGER ( a
oznacza to że można używać liczb ujemnych ):
Var
t:integer; { UWAGA TUTAJ JEST ISTOTNA ZMIANA ! }
BEGIN
FOR t:=-4 TO 8 DO WriteLn( t );
END.
A może wyświetlilibyśmy sobie tabliczkę mnożenia
? Wykonamy taką prostą do 4 x 4, najpierw jedna linia:
Uses DOS,CRT;
Var
t:word;
Begin
ClrScr;
FOR t:=1 to 4 do
Begin
GotoXY(t*4,1); {1}
Write(t);
End;
End.
{1} Kursor umieszczamy przy kolejnych przejściach w kolumnach: 4
(1*4), 8 (2*4), 12 (3*4) i 16 (4*4) ( czyli dokładnie w miejscu t*4 ) oraz
wierszu 1 i wyświetla zmienną, tylko po co nam tylko jedna linia ?
Wykonamy więc teraz tzw. pętlę zagnieżdżoną:
Uses DOS,CRT;
Var
t,n:word;
Begin
ClrScr;
FOR n:=1 to 4 do {1}
FOR t:=1 to 4 do
Begin
GotoXY(t*4,n); {2}
Write(t*n); {3}
End;
End.
ajajajaj ale się nakomplikowało :)) doszła linia {1} -
dodatkowa pętla i teraz zmienne "n" i "t" przy
kolejnych przejściach wynoszą:
n=1 t=1
n=1 t=2
n=1 t=3
n=1 t=4
n=2 t=1
n=2 t=2
n=2 t=3
n=2 t=4
n=3 t=1
n=3 t=2
n=3 t=3
n=3 t=4
n=4 t=1
n=4 t=2
n=4 t=3
n=4 t=4
Tak więc: "t" jest zwiększane o "1" aż osiągnie
wartość 4 wtedy "n" jest zwiększane o "1" a
"t" wraca do wartości początkowej ( w tym wypadku do 1 ) i
tak cały czas aż obie zmienne osiągną końcowe wartości.
{2} - Kursor jest przemieszczany do miejsca ( T*4 , N )
{3} - Wyświetla mnożenie. Kolejno: 1,2,3,4 (t*1) 2,4,6,8 (t*2)
3,6,9,12 (t*3) 4,8,12,16 (t*4)
To są właśnie pętelki zagnieżdżone ( jedna w
drugiej ) w tym przypadku są to tylko dwie, ale jeżeli potrzebujemy to
możemy użyć trzy (potrzebne jako np.: X,Y i Z w przestrzeni 3D),
cztery, pięć albo i więcej. Ale nie będę już
bardziej Cię teraz tym męczył, na razie starczy :)
Funkcja Keypressed
Składnia: Keypressed:boolean; biblioteka: CRT
Funkcja sprawdza czy w chwili aktualnej jest wciśnięty jakiś
klawisz, i jeżeli tak zwraca wartość TRUE, jeżeli nie to
FALSE. np.
Uses CRT;
Var
klawisz:boolean;
Begin
klawisz:=Keypressed;
WriteLn(klawisz);
End.
Programik podstawia do zmiennej wartość "czy jakiś
klawisz został wciśnięty", a następnie ją wyświetla.
Ale skoro jest to funkcja to można skrócić program i wyświetlać
jej wartość od razu za pomocą Write ( program wykonuje się w
ciągu ułamka sekundy i właściwie ciężko uzyskać
aby pojawił się napis TRUE ale zaraz zobaczysz jak sensownie użyć
tej funkcji ).
Uses CRT;
Begin
WriteLn(Keypressed);
End.
A teraz zobacz jak ja najczęściej wykorzystuję tą
funkcję w swoich programach:
Uses CRT;
Begin
Repeat Until Keypressed; {1}
End.
{1} Powtarzaj dopóki nie zostanie wciśnięty jakiś
klawisz ( czekaj na wciśniecie klawisza ).
W tej formie programu wydaje się, że daje ta funkcja to samo, a nawet
mniej co ReadKey. Ale z funkcją
ReadKey nie można zrobić czegoś takiego:
Uses CRT;
Var
a:Word;
Begin
a:=0; {1}
Repeat
WriteLn(a); {2}
a:=a+1; {3}
Until Keypressed; {4}
End.
{1} zacznij liczyć od 0
{2} wyświetl zawartość zmiennej
{3} zwiększ zawartość zmiennej o 1
{4} powtarzaj linie {2-3} dopóki nie zostanie wciśnięty jakiś
klawisz
Jak widzisz funkcja ta nie blokuje działania programu czekając na wciśniecie
klawisza i to jest właśnie jej niezaprzeczalna zaleta.
Procedura InitGraph
Składnia: InitGraph ( var sterownik,tryb:integer; katalog:string );
biblioteka: GRAPH
Służy do włączenia
trybu graficznego. Możliwe sterowniki ( czyli rodzaje karty graficznej ) to
:
1 = CGA
2 = MCGA
3 = EGA
4 = EGA64
5 = EGAMono
6 = IBM8514
7 = HercMono
8 = ATT400
9 = VGA
10 = PC3270
A możliwe tryby do wyświetlenia przez
daną kartę graficzną ( każdy posiada różne rozdzielczości
i ilość kolorów ) to:
CGAC0 = 0 - 320 x 200, 4 kolory z palety nr 0
CGAC1 = 1 - 320 x 200, 4 kolory z palety nr 1
CGAC2 = 2 - 320 x 200, 4 kolory z palety nr 2
CGAC3 = 3 - 320 x 200, 4 kolory z palety nr 3
CGAHi = 4 - 640 x 200, 2 kolory ( czarno-białe )
MCGAC0 = 0 - 320 x 200, 4 kolory z palety nr 0
MCGAC1 = 1 - 320 x 200, 4 kolory z palety nr 1
MCGAC2 = 2 - 320 x 200, 4 kolory z palety nr 2
MCGAC3 = 3 - 320 x 200, 4 kolory z palety nr 3
MCGAMed = 4 - 640 x 200, 2 kolory ( czarno-białe )
MCGAHi = 5 - 640 x 480, 2 kolory ( czarno-białe )
EGALo = 0 - 640 x 200, 16 kolorów
EGAHi = 1 - 640 x 350, 16 kolorów
EGA64Lo = 0 - 640 x 200, 16 kolorów
EGA64Hi = 1 - 640 x 350, 4 kolory
EGAMonoHi = 0 - 640 x 480, 2 kolory ( czarno-białe )
HercMonoHi = 0 - 720 x 348, 2 kolory ( czarno-białe )
ATT400C0 = 0 - 320 x 200, 4 kolory z palety nr 0
ATT400C1 = 1 - 320 x 200, 4 kolory z palety nr 1
ATT400C2 = 2 - 320 x 200, 4 kolory z palety nr 2
ATT400C3 = 3 - 320 x 200, 4 kolory z palety nr 3
ATT400Med = 4 - 640 x 200, 2 kolory ( czarno-białe )
ATT400Hi = 5 - 640 x 400, 2 kolory ( czarno-białe )
VGALo = 0 - 640 x 200, 16 kolorów
VGAMed = 1 - 640 x 350, 16 kolorów
VGAHi = 2 - 640 x 480, 16 kolorów
PC3270Hi = 0 - 720 x 350, 2 kolory ( czarno-białe )
IBM8514Lo = 0 - 640 x 480, 256 kolorów
IBM8514Hi = 1 - 1024 x 768, 256 kolorów
UWAGA !! Ponieważ wszystkie karty produkowane w ostatnich 4-5
latach posiadają sterownik VGA i tylko jego będziemy używać
( dokładnie to trybu VGAHi ). Jeżeli posiadasz starą kartę
Hercules ( teraz te nowe są cool :) , CGA czy EGA to przykładowe
programy będą na nich trochę dziwnie wyglądać a to z
powodu właśnie tych różnych rozdzielczości i ilości
kolorów.
No to włączmy sobie wreszcie ten tryb graficzny:
Uses GRAPH; {1}
Var
ster,tryb:integer;
Begin
ster:=VGA; tryb:=VGAHi; {2}
(ster, tryb, 'C:\BP\BGI' ); {3}
End.
{1} Zadeklarowałem do używania bibliotekę GRAPH ( to w
niej właśnie są procedury i funkcje do obsługi grafiki )
{2} Nadałem zmiennym wartości: VGA (9) i VGAHi (2)
{3} Uruchomiłem tryb graficzny. 'C:\BP\BGI' - jest to moja ścieżka
do plików *.BGI ( konkretnie do pliku EGAVGA.BGI ) możesz mieć inne
więc zmień to u siebie :)
Sam włączony tryb nam nic nie daje, ale jeżeli tego nie zrobimy
nie będzie można nic rysować. Tak więc ZAWSZE zanim coś
wykonamy w grafice trzeba wcześniej ją włączyć.
Uwaga !! lewy dolny róg to współrzędne 0,0 a nie 1,1 !!
Procedura CloseGraph
Składnia: CloseGraph; biblioteka: GRAPH
Wyłącza tryb graficzny i wraca do poprzedniego trybu tekstowego.
Procedura SetColor
Składnia: SetColor ( kolor:word ); biblioteka: GRAPH
Zmienia kolor w TRYBIE GRAFICZNYM ( TextColor w graficznym nie działa ! )
jakim zostaną wyświetlane np. kółka, linie czy prostokąty.
Ilość dostępnych kolorów w danych trybach podałem przy
opisie procedury InitGraph.
Procedura SetBkColor
Składnia: SetBkColor ( kolor:word ); biblioteka: GRAPH
Zmienia kolor tła w TRYBIE GRAFICZNYM ( TextBackGround w graficznym nie
działa ! ) Ilość dostępnych kolorów w danych trybach podałem
przy opisie procedury InitGraph.
Procedura SetFillStyle
Składnia: SetFillStyle( nrwzorca,kolor:word ); biblioteka: GRAPH
Zmienia rodzaj i kolor wypełnienia konturów wykorzystywanych przez niektóre
procedury np. przez Bar,
Bar3D itp. Domyślne
ustawienia początkowe to wzorzec wypełniania ciągłego i
numer koloru będący maksymalnym kolorem aktualnego trybu graficznego.
Rodzaje wzorca to:
EmptyFill = 0 - wypełnienie kolorem tła
SolidFill = 1 - wypełnienie ciągłe
LineFill = 2 - wypełnienie pogrubionymi liniami poziomymi
LtSlashFill = 3 - wypełnienie liniami pochyłymi w prawo
SlashFill = 4 - wypełnienie pogrubionymi liniami pochyłymi w prawo
BkSlashFill = 5 - wypełnienie pogrubionymi liniami pochyłymi w lewo
LtBkSlashFill = 6 - wypełnienie liniami pochyłymi w lewo
HatchFill = 7 - wypełnienie siatką pionową
xHatchFill = 8 - wypełnienie siatką ukośną
InteerleaveFill = 9 - wypełnienie liniami splecionymi
VideDotFill = 10 - wypełnienie kropkami
CloseDotFill = 11 - wypełnienie zagęszczonymi kropkami
UserFill = 12 - wypełnienie wzorem zdefiniowanym przez użytkownika
procedurą SetFillPattern
Procedura SetLineStyle
Składnia: SetLineStyle ( RodzLin, Wzor, Grubosc:word ); biblioteka:
GRAPH
Zmienia rodzaj linii oraz jej grubość używanej przy procedurach Line, Circle, Bar3D itd.
Rodzaje linii to:
{1} Powtarzaj dopóki nie zostanie wciśnięty jakiś
klawisz ( czekaj na wciśniecie klawisza ).
W tej formie programu wydaje się, że daje ta funkcja to samo, a nawet
mniej co ReadKey.Ale z funkcją
ReadKey nie można zrobić czegoś takiego:
Uses CRT;
Var
a:Word;
Begin
a:=0; {1}
Repeat
WriteLn(a); {2}
a:=a+1; {3}
Until Keypressed; {4}
End.
{1} zacznij liczyć od 0
{2} wyświetl zawartość zmiennej
{3} zwiększ zawartość zmiennej o 1
{4} powtarzaj linie {2-3} dopóki nie zostanie wciśnięty jakiś
klawisz
Jak widzisz funkcja ta nie blokuje działania programu czekając na wciśniecie
klawisza i to jest właśnie jej niezaprzeczalna zaleta.
Procedura InitGraph
Składnia: InitGraph ( var sterownik,tryb:integer; katalog:string );
biblioteka: GRAPH
Służy do włączenia
trybu graficznego. Możliwe sterowniki ( czyli rodzaje karty graficznej ) to
:
1 = CGA
2 = MCGA
3 = EGA
4 = EGA64
5 = EGAMono
6 = IBM8514
7 = HercMono
8 = ATT400
9 = VGA
10 = PC3270
A możliwe tryby do wyświetlenia przez
daną kartę graficzną ( każdy posiada różne rozdzielczości
i ilość kolorów ) to:
CGAC0 = 0 - 320 x 200, 4 kolory z palety nr 0
CGAC1 = 1 - 320 x 200, 4 kolory z palety nr 1
CGAC2 = 2 - 320 x 200, 4 kolory z palety nr 2
CGAC3 = 3 - 320 x 200, 4 kolory z palety nr 3
CGAHi = 4 - 640 x 200, 2 kolory ( czarno-białe )
MCGAC0 = 0 - 320 x 200, 4 kolory z palety nr 0
MCGAC1 = 1 - 320 x 200, 4 kolory z palety nr 1
MCGAC2 = 2 - 320 x 200, 4 kolory z palety nr 2
MCGAC3 = 3 - 320 x 200, 4 kolory z palety nr 3
MCGAMed = 4 - 640 x 200, 2 kolory ( czarno-białe )
MCGAHi = 5 - 640 x 480, 2 kolory ( czarno-białe )
EGALo = 0 - 640 x 200, 16 kolorów
EGAHi = 1 - 640 x 350, 16 kolorów
EGA64Lo = 0 - 640 x 200, 16 kolorów
EGA64Hi = 1 - 640 x 350, 4 kolory
EGAMonoHi = 0 - 640 x 480, 2 kolory ( czarno-białe )
HercMonoHi = 0 - 720 x 348, 2 kolory ( czarno-białe )
ATT400C0 = 0 - 320 x 200, 4 kolory z palety nr 0
ATT400C1 = 1 - 320 x 200, 4 kolory z palety nr 1
ATT400C2 = 2 - 320 x 200, 4 kolory z palety nr 2
ATT400C3 = 3 - 320 x 200, 4 kolory z palety nr 3
ATT400Med = 4 - 640 x 200, 2 kolory ( czarno-białe )
ATT400Hi = 5 - 640 x 400, 2 kolory ( czarno-białe )
VGALo = 0 - 640 x 200, 16 kolorów
VGAMed = 1 - 640 x 350, 16 kolorów
VGAHi = 2 - 640 x 480, 16 kolorów
PC3270Hi = 0 - 720 x 350, 2 kolory ( czarno-białe )
IBM8514Lo = 0 - 640 x 480, 256 kolorów
IBM8514Hi = 1 - 1024 x 768, 256 kolorów
UWAGA !! Ponieważ wszystkie karty produkowane w ostatnich 4-5
latach posiadają sterownik VGA i tylko jego będziemy używać
( dokładnie to trybu VGAHi ). Jeżeli posiadasz starą kartę
Hercules ( teraz te nowe są cool :) , CGA czy EGA to przykładowe
programy będą na nich trochę dziwnie wyglądać a to z
powodu właśnie tych różnych rozdzielczości i ilości
kolorów.
No to włączmy sobie wreszcie ten tryb graficzny:
Uses GRAPH; {1}
Var
ster,tryb:integer;
Begin
ster:=VGA; tryb:=VGAHi; {2}
(ster, tryb, 'C:\BP\BGI' ); {3}
End.
{1} Zadeklarowałem do używania bibliotekę GRAPH ( to w
niej właśnie są procedury i funkcje do obsługi grafiki )
{2} Nadałem zmiennym wartości: VGA (9) i VGAHi (2)
{3} Uruchomiłem tryb graficzny. 'C:\BP\BGI' - jest to moja ścieżka
do plików *.BGI ( konkretnie do pliku EGAVGA.BGI ) możesz mieć inne
więc zmień to u siebie :)
Sam włączony tryb nam nic nie daje, ale jeżeli tego nie zrobimy
nie będzie można nic rysować. Tak więc ZAWSZE zanim coś
wykonamy w grafice trzeba wcześniej ją włączyć.
Uwaga !! lewy dolny róg to współrzędne 0,0 a nie 1,1 !!
Procedura CloseGraph
Składnia: CloseGraph; biblioteka: GRAPH
Wyłącza tryb graficzny i wraca do poprzedniego trybu tekstowego.
Procedura SetColor
Składnia: SetColor ( kolor:word ); biblioteka: GRAPH
Zmienia kolor w TRYBIE GRAFICZNYM ( TextColor w graficznym nie działa ! )
jakim zostaną wyświetlane np. kółka, linie czy prostokąty.
Ilość dostępnych kolorów w danych trybach podałem przy
opisie procedury InitGraph.
Procedura SetBkColor
Składnia: SetBkColor ( kolor:word ); biblioteka: GRAPH
Zmienia kolor tła w TRYBIE GRAFICZNYM ( TextBackGround w graficznym nie
działa ! ) Ilość dostępnych kolorów w danych trybach podałem
przy opisie procedury InitGraph.
Procedura SetFillStyle
Składnia: SetFillStyle( nrwzorca,kolor:word ); biblioteka: GRAPH
Zmienia rodzaj i kolor wypełnienia konturów wykorzystywanych przez niektóre
procedury np. przez Bar, Bar3D itp. Domyślne
ustawienia początkowe to wzorzec wypełniania ciągłego i
numer koloru będący maksymalnym kolorem aktualnego trybu graficznego.
Rodzaje wzorca to:
EmptyFill = 0 - wypełnienie kolorem tła
SolidFill = 1 - wypełnienie ciągłe
LineFill = 2 - wypełnienie pogrubionymi liniami poziomymi
LtSlashFill = 3 - wypełnienie liniami pochyłymi w prawo
SlashFill = 4 - wypełnienie pogrubionymi liniami pochyłymi w prawo
BkSlashFill = 5 - wypełnienie pogrubionymi liniami pochyłymi w lewo
LtBkSlashFill = 6 - wypełnienie liniami pochyłymi w lewo
HatchFill = 7 - wypełnienie siatką pionową
xHatchFill = 8 - wypełnienie siatką ukośną
InteerleaveFill = 9 - wypełnienie liniami splecionymi
VideDotFill = 10 - wypełnienie kropkami
CloseDotFill = 11 - wypełnienie zagęszczonymi kropkami
UserFill = 12 - wypełnienie wzorem zdefiniowanym przez użytkownika
procedurą SetFillPattern
Procedura SetLineStyle
Składnia: SetLineStyle ( RodzLin, Wzor, Grubosc:word ); biblioteka:
GRAPH
Zmienia rodzaj linii oraz jej grubość używanej przy procedurach Line, Circle, Bar3D itd.
Rodzaje linii to:
SolidLn = 0 - ciągła
DottedLn = 1 - kropkowana
CenterLn = 2 - symetryczna
DashedLn = 3 - przerywana
UserBitLn = 4 - o wzorze zdefiniowanym przez użytkownika
Wzor - jest to zdefiniowane przez użytkownika kolejne 16 pikseli
nowej nietypowej linii ( rodzlin=4 ). Jeżeli rodzaj linii jest różny
od 4 to pod wzór możemy wstawić jakąkolwiek liczbę gdyż
nie będzie ona brana pod uwagę.
Rodzaje grubości to:
NormWidth = 1 - linia normalna
ThickWidth = 3 - linia pogrubiona
przykład: SetLineStyle(0,0,3);
Procedura Line
Składnia: Line ( X1,Y1,X2,Y2:integer ); biblioteka: GRAPH
Procedura rysuje linię zaczynającą się w punkcie X1,Y1 a kończącą
się w X2,Y2 kolorem określonym przez procedurę SetColor
Uses GRAPH,CRT;
Var
ster,tryb:integer;
Begin
ster:=VGA; tryb:=VGAHi;
ster:=VGA; tryb:=VGAHi;
InitGraph(ster, tryb, 'C:\BP\BGI' );
Line(30,30,610,450);
Repeat Until Keypressed;
CloseGraph;
End.
Procedura Circle
Składnia: Circle ( X,Y:integer; R:word ); biblioteka: GRAPH
Procedura rysuje koło o środku umieszczonym o współrzędnych
X,Y, promieniu R i kolorze określonym przez procedurę SetColor.
Uses GRAPH,CRT;
Var
ster,tryb:integer;
Begin
ster:=VGA; tryb:=VGAHi;
InitGraph(ster, tryb, 'C:\BP\BGI' );
Circle(320,240,40); {1}
Repeat Until Keypressed; {2}
CloseGraph;
End.
{1} Rysujemy kołko o współrzędnych 320,240 ( jest to
środek ekranu gdyż włączyliśmy tryb VGAHi, którego
rozdzielczość to: 640x480 ) i o promieniu 40
{2} Czekamy aż zostanie wciśnięty jakiś klawisz ( spróbuj
usunąć tą linię to dowiesz się dlaczego jest taka ważna
)
Procedura Rectangle
Składnia: Rectangle ( X1,Y1,X2,Y2:integer ); biblioteka: GRAPH
Procedura rysuje prostokąt. X1,Y1 to współrzędne lewego górnego
rogu, a X2,Y2 to współrzędne lewego dolnego rogu ( są to
przeciwległe wierzchołki )
Uses GRAPH,CRT;
Var
ster,tryb:integer;
Begin
ster:=VGA; tryb:=VGAHi;
InitGraph(ster, tryb, 'C:\BP\BGI' );
Rectangle(30,30,610,450);
Repeat Until Keypressed;
CloseGraph;
End.
Procedura FloodFill
Składnia: FloodFill ( X,Y:integer; kolorgranicy:word ); biblioteka:
GRAPH
Procedura wypełnia aktualnym kolorem i wzorem ( SetFillStyle) obszar
ograniczony brzegiem o kolorze "kolorgranicy" tzn. Jeżeli przy
wypełnianiu danego obszaru procedura napotka na jakąś np. linię
wykonaną kolorem "kolorgranicy" to zachowuje się jakby to był
dla niej mur nie do przejścia i zostawia i jego i to co się za nim
znajduje w spokoju :) Punkt X,Y jest miejscem od którego procedura zaczyna wypełniać
obszar.
Uses GRAPH,CRT;
Var
ster,tryb:integer;
Begin
ster:=VGA; tryb:=VGAHi;
InitGraph(ster, tryb, 'C:\BP\BGI' );
SetColor(green);
Rectangle(30,30,120,120);
Rectangle(10,10,100,100);
FloodFill(50,50,Green);
Repeat Until Keypressed;
CloseGraph;
End.
Program wypełnia obszar który jest wspólny dla obu prostokątów.
Procedura Bar
Składnia: Bar ( X1,Y1,X2,Y2:integer); biblioteka: GRAPH
Procedura rysuje wypełniony prostokąt. X1,Y1 to współrzędne
lewego górnego rogu, a X2,Y2 to współrzędne lewego dolnego rogu ( są
to przeciwległe wierzchołki ), kolor ramki jest określony przez
procedurę SetColor, a kolor wypełnienia
przez proceduręSetFillStyle.
Uses GRAPH,CRT;
Var
ster,tryb:integer;
Begin
ster:=VGA; tryb:=VGAHi;
InitGraph(ster, tryb, 'C:\BP\BGI' );
SetColor(8);
SetFillStyle(1,5);
Bar(30,30,610,450);
Repeat Until Keypressed;
CloseGraph;
End.
Procedura Bar3D
Składnia: Bar3D ( X1,Y1,X2,Y2:integer; B:word; TOP:boolean );
biblioteka: GRAPH
Procedura rysuje trójwymiarowy wypełniony prostokąt. X1,Y1 to współrzędne
lewego górnego rogu przedniej ścianki, X2,Y2 to współrzędne
lewego dolnego rogu przedniej ścianki, zmienna B jest to głębokość
naszego prostopadłościanu, zmienna TOP określa czy górna
powierzchnia jest widoczna TRUE czy niewidoczna FALSE. Granice słupka
rysowane są liniami typu określonego przez procedurę SetLineStyle aktualnym
kolorem (SetColor) i
aktualnym wzorem i kolorem wypełnienia ( SetFillStyle
)
Uses GRAPH,CRT;
Var
ster,tryb:integer;
Begin
ster:=VGA; tryb:=VGAHi;
InitGraph(ster, tryb, 'C:\BP\BGI' );
SetColor(4);
SetFillStyle(10,8);
Bar3D(50,50,590,430,20,TRUE);
Repeat Until Keypressed;
CloseGraph;
End.
Procedura PutPixel
Składnia: PutPixel ( X,Y:integer; Kolor:word ); biblioteka: GRAPH
Procedura wyświetla na ekranie jeden punkt o kolorze "Kolor",
jest to przydatne przy precyzyjnym rysowaniu.
Uses GRAPH,CRT;
Var
ster,tryb:integer;
Begin
ster:=VGA; tryb:=VGAHi;
InitGraph(ster, tryb, 'C:\BP\BGI' );
PutPixel(320,240,15);
Repeat Until Keypressed;
CloseGraph;
End.
Programik wyświetla biały punkt na samym środku ekranu.
Procedura OutTextXY
Składnia: OutTextXY ( X,Y:integer; S:string ); biblioteka: GRAPH
Procedura wyświetla na ekranie tekst określony przez zmienną
"S" rozpoczynając od współrzędnych X,Y i w aktualnym
kolorze ( SetColor)
Uses GRAPH,CRT;
Var
ster,tryb:integer;
Begin
ster:=VGA; tryb:=VGAHi;
InitGraph(ster, tryb, 'C:\BP\BGI' );
OutTextXY(200,100,'Oto tekst');
Repeat Until Keypressed;
CloseGraph;
End.
Procedura ClearDevice
Składnia: ClearDevice; biblioteka: GRAPH
Procedura czyści ekran graficzny. Przykład:
Uses GRAPH,CRT;
Var
ster,tryb:integer;
Begin
ster:=VGA; tryb:=VGAHi;
InitGraph(ster, tryb, 'C:\BP\BGI' );
Circle(50,50,30);
Delay(2000);
ClearDevice;
Circle(150,200,70);
Repeat Until Keypressed;
CloseGraph;
End.
Funkcja ReadKey
Składnia: znak:=ReadKey;
Jest to funkcja, która znajduje się w bibliotece CRT i zwraca znak
odczytany z klawiatury ( nie cały ciąg znaków STRING a tylko jeden
typu CHAR ). np.
USES CRT;
Var
znak:char;
Begin
WriteLn( 'Wcisnij jakis klawisz...');
znak:=ReadKey;
WriteLn( 'Wcisniety zostal klawisz: ',znak );
End.
Program czeka na wciśnięcie jakiegokolwiek klawisza i wyświetla
go ( oczywiście nie mowię tu o klawiszach SHIFT, ALT czy CRTL bo one
działają tylko w połączeniu z innymi znakami :)
Funkcja Chr
Składnia:
znak:=Chr(liczba);
znak:=#liczba;
Każdy litera, cyfra czy inny znak (np. ramki) posiadają swój własny
numer (dokładniej jest to liczba od 0 do 255) i jest odczytywany z tablicy
kodów ASCII, np. znakowi 'A' odpowiada liczba 65, znakowi 'a' liczba 97, a
znakowi '2' liczba 50. Aby można było zamieniać liczbę na
znak używa się właśnie funkcji Chr, która zwraca znak typu
CHAR np.
Begin
WriteLn(chr(70));
WriteLn(chr(43));
WriteLn(#43);
WriteLn(chr(39));
End.
Program wyświetli w kolejnych liniach znaki: 'F', '+', jeszcze
jeden '+' ( zamiast chr() mozesz używać znaczka # wynik jest ten sam )
i w ostatniej linii pojawi się niedający się zwyczajnie wyświetlić
znaku apostrofu. A wiesz może dlaczego nie można go zwyczajnie wyświetlić
? Odpowiedź jest prosta: jeżeli wstawimy go np. w procedurze WriteLn
to procedura uzna go za znak zaczynający lub kończący zmienną
typu string, nie da się więc tak zrobić:
WriteLn( 'Alfabet Morse'a' );
Pascal widzi tylko zmienną 'Alfabet Morse' i nie wie co dalej zrobić
z resztą ( a' ) a ponieważ zmienne String można łączyć
ze zmiennymi Char, tak więc poprawna linijka wyglądała by tak:
WriteLn( 'Alfabet Morse'+chr(39)+'a' );
lub tak:
WriteLn( 'Alfabet Morse'+#39+'a' );
ewelntualnie tak:
WriteLn( 'Alfabet Morse',#39,'a' );
Niektóre kody są znakami sterującymi np. chr(13) odpowiada
klawiszowi ENTER, chr(27) klawiszowi ESC, chr(8) klawiszowi BACKSPACE, a chr(7)
odpowiada pipnięciu przez głośniczek komputera, spróbuj coś
takiego:
Begin
WriteLn(chr(7));
End.
ster:=VGA; tryb:=VGAHi;
InitGraph(ster, tryb, 'C:\BP\BGI' );
Line(30,30,610,450);
Repeat Until Keypressed;
CloseGraph;
End.
Procedura Circle
Składnia: Circle ( X,Y:integer; R:word ); biblioteka: GRAPH
Procedura rysuje koło o środku umieszczonym o współrzędnych
X,Y, promieniu R i kolorze określonym przez procedurę SetColor.
Uses GRAPH,CRT;
Var
ster,tryb:integer;
Begin
ster:=VGA; tryb:=VGAHi;
InitGraph(ster, tryb, 'C:\BP\BGI' );
Circle(320,240,40); {1}
Repeat Until Keypressed; {2}
CloseGraph;
End.
{1} Rysujemy kołko o współrzędnych 320,240 ( jest to
środek ekranu gdyż włączyliśmy tryb VGAHi, którego
rozdzielczość to: 640x480 ) i o promieniu 40
{2} Czekamy aż zostanie wciśnięty jakiś klawisz ( spróbuj
usunąć tą linię to dowiesz się dlaczego jest taka ważna
)
Procedura Rectangle
Składnia: Rectangle ( X1,Y1,X2,Y2:integer ); biblioteka: GRAPH
Procedura rysuje prostokąt. X1,Y1 to współrzędne lewego górnego
rogu, a X2,Y2 to współrzędne lewego dolnego rogu ( są to
przeciwległe wierzchołki )
Uses GRAPH,CRT;
Var
ster,tryb:integer;
Begin
ster:=VGA; tryb:=VGAHi;
InitGraph(ster, tryb, 'C:\BP\BGI' );
Rectangle(30,30,610,450);
Repeat Until Keypressed;
CloseGraph;
End.
Procedura FloodFill
Składnia: FloodFill ( X,Y:integer; kolorgranicy:word ); biblioteka:
GRAPH
Procedura wypełnia aktualnym kolorem i wzorem ( SetFillStyle) obszar
ograniczony brzegiem o kolorze "kolorgranicy" tzn. Jeżeli przy
wypełnianiu danego obszaru procedura napotka na jakąś np. linię
wykonaną kolorem "kolorgranicy" to zachowuje się jakby to był
dla niej mur nie do przejścia i zostawia i jego i to co się za nim
znajduje w spokoju :) Punkt X,Y jest miejscem od którego procedura zaczyna wypełniać
obszar.
Uses GRAPH,CRT;
Var
ster,tryb:integer;
Begin
ster:=VGA; tryb:=VGAHi;
InitGraph(ster, tryb, 'C:\BP\BGI' );
SetColor(green);
Rectangle(30,30,120,120);
Rectangle(10,10,100,100);
FloodFill(50,50,Green);
Repeat Until Keypressed;
CloseGraph;
End.
Program wypełnia obszar który jest wspólny dla obu prostokątów.
Procedura Bar
Składnia: Bar ( X1,Y1,X2,Y2:integer); biblioteka: GRAPH
Procedura rysuje wypełniony prostokąt. X1,Y1 to współrzędne
lewego górnego rogu, a X2,Y2 to współrzędne lewego dolnego rogu ( są
to przeciwległe wierzchołki ), kolor ramki jest określony przez
procedurę SetColor, a kolor wypełnienia
przez proceduręSetFillStyle.
Uses GRAPH,CRT;
Var
ster,tryb:integer;
Begin
ster:=VGA; tryb:=VGAHi;
InitGraph(ster, tryb, 'C:\BP\BGI' );
SetColor(8);
SetFillStyle(1,5);
Bar(30,30,610,450);
Repeat Until Keypressed;
CloseGraph;
End.
Procedura Bar3D
Składnia: Bar3D ( X1,Y1,X2,Y2:integer; B:word; TOP:boolean );
biblioteka: GRAPH
Procedura rysuje trójwymiarowy wypełniony prostokąt. X1,Y1 to współrzędne
lewego górnego rogu przedniej ścianki, X2,Y2 to współrzędne
lewego dolnego rogu przedniej ścianki, zmienna B jest to głębokość
naszego prostopadłościanu, zmienna TOP określa czy górna
powierzchnia jest widoczna TRUE czy niewidoczna FALSE. Granice słupka
rysowane są liniami typu określonego przez procedurę SetLineStyle aktualnym
kolorem ( SetColor) i
aktualnym wzorem i kolorem wypełnienia ( SetFillStyle)
Uses GRAPH,CRT;
Var
ster,tryb:integer;
Begin
ster:=VGA; tryb:=VGAHi;
InitGraph(ster, tryb, 'C:\BP\BGI' );
SetColor(4);
SetFillStyle(10,8);
Bar3D(50,50,590,430,20,TRUE);
Repeat Until Keypressed;
CloseGraph;
End.
Procedura PutPixel
Składnia: PutPixel ( X,Y:integer; Kolor:word ); biblioteka: GRAPH
Procedura wyświetla na ekranie jeden punkt o kolorze "Kolor",
jest to przydatne przy precyzyjnym rysowaniu.
Uses GRAPH,CRT;
Var
ster,tryb:integer;
Begin
ster:=VGA; tryb:=VGAHi;
InitGraph(ster, tryb, 'C:\BP\BGI' );
PutPixel(320,240,15);
Repeat Until Keypressed;
CloseGraph;
End.
Programik wyświetla biały punkt na samym środku ekranu.
Procedura OutTextXY
Składnia: OutTextXY ( X,Y:integer; S:string ); biblioteka: GRAPH
Procedura wyświetla na ekranie tekst określony przez zmienną
"S" rozpoczynając od współrzędnych X,Y i w aktualnym
kolorze ( SetColor)
Uses GRAPH,CRT;
Var
ster,tryb:integer;
Begin
ster:=VGA; tryb:=VGAHi;
InitGraph(ster, tryb, 'C:\BP\BGI' );
OutTextXY(200,100,'Oto tekst');
Repeat Until Keypressed;
CloseGraph;
End.
Procedura ClearDevice
Składnia: ClearDevice; biblioteka: GRAPH
Procedura czyści ekran graficzny. Przykład:
Uses GRAPH,CRT;
Var
ster,tryb:integer;
Begin
ster:=VGA; tryb:=VGAHi;
InitGraph(ster, tryb, 'C:\BP\BGI' );
Circle(50,50,30);
Delay(2000);
ClearDevice;
Circle(150,200,70);
Repeat Until Keypressed;
CloseGraph;
End.
Funkcja ReadKey
Składnia: znak:=ReadKey;
Jest to funkcja, która znajduje się w bibliotece CRT i zwraca znak
odczytany z klawiatury ( nie cały ciąg znaków STRING a tylko jeden
typu CHAR ). np.
USES CRT;
Var
znak:char;
Begin
WriteLn( 'Wcisnij jakis klawisz...');
znak:=ReadKey;
WriteLn( 'Wcisniety zostal klawisz: ',znak );
End.
Program czeka na wciśnięcie jakiegokolwiek klawisza i wyświetla
go ( oczywiście nie mowię tu o klawiszach SHIFT, ALT czy CRTL bo one
działają tylko w połączeniu z innymi znakami :)
Funkcja Chr
Składnia:
znak:=Chr(liczba);
znak:=#liczba;
Każdy litera, cyfra czy inny znak (np. ramki) posiadają swój własny
numer (dokładniej jest to liczba od 0 do 255) i jest odczytywany z tablicy
kodów ASCII, np. znakowi 'A' odpowiada liczba 65, znakowi 'a' liczba 97, a
znakowi '2' liczba 50. Aby można było zamieniać liczbę na
znak używa się właśnie funkcji Chr, która zwraca znak typu
CHAR np.
Begin
WriteLn(chr(70));
WriteLn(chr(43));
WriteLn(#43);
WriteLn(chr(39));
End.
Program wyświetli w kolejnych liniach znaki: 'F', '+', jeszcze
jeden '+' ( zamiast chr() mozesz używać znaczka # wynik jest ten sam )
i w ostatniej linii pojawi się niedający się zwyczajnie wyświetlić
znaku apostrofu. A wiesz może dlaczego nie można go zwyczajnie wyświetlić
? Odpowiedź jest prosta: jeżeli wstawimy go np. w procedurze WriteLn
to procedura uzna go za znak zaczynający lub kończący zmienną
typu string, nie da się więc tak zrobić:
WriteLn( 'Alfabet Morse'a' );
Pascal widzi tylko zmienną 'Alfabet Morse' i nie wie co dalej zrobić
z resztą ( a' ) a ponieważ zmienne String można łączyć
ze zmiennymi Char, tak więc poprawna linijka wyglądała by tak:
WriteLn( 'Alfabet Morse'+chr(39)+'a' );
lub tak:
WriteLn( 'Alfabet Morse'+#39+'a' );
ewelntualnie tak:
WriteLn( 'Alfabet Morse',#39,'a' );
Niektóre kody są znakami sterującymi np. chr(13) odpowiada
klawiszowi ENTER, chr(27) klawiszowi ESC, chr(8) klawiszowi BACKSPACE, a chr(7)
odpowiada pipnięciu przez głośniczek komputera, spróbuj coś
takiego:
Begin
WriteLn(chr(7));
End.
lub ten poniżej który czeka na wciśnięcie klawisza ESC (
na żaden inny nie reaguje ):
USES CRT;
Var
znak:char;
Begin
ClrScr;
WriteLn('Wcisnij klawisz ESC');
Repeat
znak:=ReadKey;
Until znak=Chr(27);
End.
Funkcja Ord
Składnia: liczba:=Ord(znak);
Ta funkcja jest podobna do funkcji Chr, tylko że w niej zamieniane jest na
odwrót, nie liczby na znaki, tylko znaki na liczby :) np. ord('A')=65
ord('a')=97 ord('2')=50 itd. np.
USES CRT;
Var
znak:char;
Begin
Repeat
znak:=ReadKey;
WriteLn(znak,' ',ord(znak));
Until znak=Chr(27);
End.
Program ten czeka na wciśnięcie znaku i wyświetla go,
podając jednocześnie jego kod ASCII. Działa tak długo póki
nie wciśniemy klawisza ESC.
Obsługa Klawiszy
Rozszerzonych
Klawisze rozszerzone podobnie jak zwykłe
odczytuje się funkcją ReadKey. Jest jednak jedna różnica, jeżeli
to jest klawisz rozszerzony to funkcja ReadKey zwróci nam wartość
chr(0), aby rozpoznać który to klawisz z rozszerzonych, to należy
POWTÓRNIE ODCZYTAĆ KLAWISZ funkcją ReadKey. Aby to objaśnić
obejrzyj przykład:
USES CRT;
Var
normalny,rozszerzony:char;
Begin
WriteLn( 'Wcisnij jakis klawisz...');
normalny:=ReadKey;
if normalny=chr(0) then
Begin
rozszerzony:=ReadKey;
WriteLn( 'Wcisniety zostal rozszerzony klawisz: ',rozszerzony );
End Else WriteLn( 'Wcisniety zostal klawisz: ',normalny );
End.
Program czeka na wciśnięcie klawisza, jeżeli jest to
rozszerzony ( czyli przeczytany=chr(0) ) powtórnie go czyta i wyświetla
wartość ROZSZERZONY, jeżeli nie to omija powtórne czytanie i wyświetla
wartość NORMALNY. Tak więc jeżeli wciśniemy klawisz
"kursor w prawo" to otrzymamy wartość "rozszerzony
M" itd. zróbmy więc teraz podstawę do obsługi kursorów:
USES CRT;
Var
c1,c2:char;
Begin
Repeat
c1:=ReadKey;
c2:=' '; {1}
if c1=chr(0) then c2:=ReadKey; {2}
if c2='H' then WriteLn('Kursor w górę');
if c2='P' then WriteLn('Kursor w dół');
if c2='M' then WriteLn('Kursor w prawo');
if c2='K' then WriteLn('Kursor w lewo');
Until c1=chr(27);
End.
Program reaguje tylko na klawisze kursora i ESC. W linii {1} musiałem
jakoś wyzerować zmienną "C2" a to dlatego że jeżeli
wcisnęlibyśmy klawisz np. "kursor w lewo" a potem jakiś
zwykły np. spację to program by wyświetlił ponownie
"kursor w lewo" gdyż w linii {2} nie odczytałby powtórnie
klawisza { c1 byłoby wtedy różne od chr(0) } i pozostałaby w
zmiennej C2 poprzednia wartość.
Procedura Inc
Składnia: Inc(zmienna);
Normalnie to jest procedura zwiększająca wartość zmiennej o
"1" czyli np. "X:=X+1" to jest to samo co
"Inc(X)". Ale ta procedura zwiększa również inne typy np.
typ CHAR jeżeli zmienna C= 'a' to po wykonaniu "Inc(C);" zmienna
C będzie miała wartość o "1" większą
czyli: 'b'.
Procedura Dec
Składnia: Dec(zmienna);
Jest to procedura podobna do Inc z tą tylko różnicą że ta
nie zwiększa o "1" tylko ZMNIEJSZA o "1"
Menu w trybie tekstowym
sterowane kursorami
Na początek zrobimy menu z trzema opcjami
wyboru, używając tu tablice bo bez nich byłoby ciężko,
będzie to trochę większy program od tych co robiliśmy do tej
pory ale mam nadzieję że sobie poradzisz :)
USES CRT;
Var
c1,c2:char;
y:byte;
tablica:array[1..3]of string;
Procedure info; {1}
Begin
End;
Procedure glowny_program; {2}
Begin
End;
Begin
Tablica[1]:=' Info '; {3}
Tablica[2]:=' Program '; {4}
Tablica[3]:=' Wyjscie '; {5}
ClrScr;
TextColor(15);
For y:=1 to 3 do {6}
Begin {7}
TextColor(15); {8}
TextBackGround(0); {9}
GotoXY(32,11+y); {10}
Write(tablica[y]); {11}
End; {12}
y:=1; {13}
Repeat {14}
TextColor(0); {15}
TextBackGround(15); {16}
GotoXY(32,11+y); {17}
Write(tablica[y]); {18}
c1:=ReadKey; {19}
c2:=' '; {20}
If c1=Chr(0) Then c2:=ReadKey; {21}
TextColor(15); {22}
TextBackGround(0); {23}
GotoXY(32,11+y); {24}
Write(tablica[y]); {25}
If c2='H' Then Dec(y); {26}
If c2='P' Then Inc(y); {27}
If y=0 Then y:=3; {28}
If y=4 Then y:=1; {29}
If c1=Chr(27) Then y:=3; {30}
Until (c1=chr(27)) or (c1=chr(13)); {31}
If y=1 Then info; {32}
If y=2 Then glowny_program; {33}
End.
Teraz wyjaśnienie:
{1, 2} - przykładowe procedury które będą uruchamiane po
wybraniu ich z menu
{3 - 5} - wprowadzenie do zmiennych wartości kolejnych pól menu
{6 - 12} - wyświetlenie kolejnych pozycji menu
{13} - wprowadzenie do zmiennej Y wartości "1" będzie to
nasza zmienna informująca na której aktualnie pozycji menu znajdujemy się
{14 - 31} początek pętli kończącej się dopiero po wciśnięciu
klawisza ENTER lub ESC
{15, 16} zmiana kolorów tła i tekstu na przeciwny (tło białe,
tekst czarny)
{17, 18} wyświetlenie Y pozycji menu w nowych kolorach
{19} czekanie na wciśnięcie klawisza
{20} wyczyszczenie zmiennej C2
{21} odczytanie znaku jeżeli jest to klawisz rozszerzony
{22, 23} przywrócenie normalnych kolorów ( tło czarne, tekst biały )
{24, 25} wyświetlenie Y pozycji menu w zwykłych kolorach ( zrobiliśmy
to dlatego że jeżeli zmieni się pozycja w menu aby poprzednia już
nam się nie "świeciła"
{26} jeżeli klawisz to "kursor górę" zmniejsz zawartość
zmiennej Y o "1"
{27} jeżeli klawisz to "kursor dół" zwiększ zawartość
zmiennej Y o "1"
{28} jeżeli Y=0 ( czyli poprzednio menu było na 1 pozycji i pojechaliśmy
w górę ) podstaw do Y wartość "3" (dzięki temu
aktualną pozycją stanie się 3 i będzie nam się tak cały
czas "kręcić w kółko" )
{29} jeżeli Y=4 ( czyli poprzednio menu było na 3 pozycji i pojechaliśmy
w dół ) podstaw do Y wartość "1" ( tak więc
powracamy do "1" pozycji )
{30} jeżeli wciśnięty klawisz to ESC podstaw do zmiennej Y=3 (
czyli pozycję "wyjście", zwróć uwagę że
gdybyś tego nie zrobił, a akurat znajdowałbyś się na
pozycji np. "Info" to po wciśnięciu ESC i tak uruchomiła
by się procedura Info ! )
{31} jeżeli wciśnięty klawisz to ENTER lub ESC opuść pętlę
{32 - 33} uruchom odpowiednie procedury w zależności od wartości
zmiennej Y
Ot i cała filozofia Menu ( trochę gorzej jest jeżeli pozycji jest
więcej niż wierszy na ekranie ale nie będę teraz bardziej
tym męczył :) Chcę abyś teraz przypatrzył się
liniom {8 - 11}, {15 - 18} i {22 - 25}. Linie te są prawie identyczne tak
więc aż kusi aby zrobić z nich procedurkę :) A oto program z
tą właśnie dodatkową procedurką:
USES CRT;
Var
c1,c2:char;
y:byte;
tablica:array[1..3]of string;
Procedure info;
Begin
End;
Procedure glowny_program;
Begin
End;
Procedure wyswietl(ktory,kolor,tlo:byte); {1}
Begin
TextColor(kolor); {2}
TextBackGround(tlo); {3}
GotoXY(32,11+ktory); {4}
Write(tablica[ktory]); {5}
End;
Begin
Tablica[1]:=' Info ';
Tablica[2]:=' Program ';
Tablica[3]:=' Wyjscie ';
ClrScr;
For y:=1 To 3 Do wyswietl(y,15,0); {6}
y:=1;
Repeat
wyswietl(y,0,15); {7}
c1:=ReadKey;
c2:=' ';
If c1=chr(0) Then c2:=ReadKey;
wyswietl(y,15,0); {8}
If c2='H' Then Dec(y);
If c2='P' Then Inc(y);
If y=0 Then y:=3;
If y=4 Then y:=1;
If c1=chr(27) Then y:=3;
Until (c1=chr(27)) or (c1=chr(13));
If y=1 Then info;
If y=2 Then glowny_program;
End.
{1} nowa procedura, jej parametrami są: "KTORY" będący
zmienną informującą którą pozycję wyświetlić,
"KOLOR" - kolor tekstu i "TLO" kolor tła
{2, 3} zmieniają kolor tekstu i tła
{4, 5} wyświetlenie pozycji "KTORY" w kolorach "KOLOR"
i "TLO"
Procedura Str
Składnia: Str(liczba,tekst:string); LICZBA
może być typu BYTE, INTEGER, WORD itd.
Procedura zamienia liczbę "LICZBA" na zmienną typu
"STRING" np.
Var
X:Byte;
S:String;
Begin
X:=48;
Str(x,s);
WriteLn(s);
End.
Tworzenie Bibliotek
Przy nauce tworzenia bibliotek zrobimy sobie
procedurę, która czasami może się nam przydać, mianowicie
procedurę rysującą ramkę w trybie tekstowym. Wykorzystamy również
dodatkowo procedurę WriteXY, którą
utworzyliśmy w lekcji 3.
USES CRT;
PROCEDURE WriteXY(x,y:byte; s:string);
Begin
GotoXY(x,y);
Write(s);
End;
PROCEDURE Ramka(x1,y1,x2,y2:byte);
Var {1}
t:byte;
Begin
WriteXY(x1,y1,chr(201)); {2}
WriteXY(x1,y2,chr(200)); {3}
WriteXY(x2,y1,chr(187)); {4}
WriteXY(x2,y2,chr(188)); {5}
For t:=x1+1 To x2-1 Do WriteXY(t,y1,chr(205)); {6}
For t:=x1+1 To x2-1 Do WriteXY(t,y2,chr(205)); {7}
For t:=y1+1 To y2-1 Do WriteXY(x1,t,chr(186)); {8}
For t:=y1+1 To y2-1 Do WriteXY(x2,t,chr(186)); {9}
End;
Begin
Clrscr;
Ramka(5,5,12,9);
End.
Zmienne:
X1 - współrzędna X lewego górnego rogu ramki
Y1 - współrzędna Y lewego górnego rogu ramki
X2 - współrzędna X prawego dolnego rogu ramki
Y2 - współrzędna Y prawego dolnego rogu ramki
{1} Tego wcześniej nie było: definicja zmiennej LOKALNEJ. W przeciwieństwie
do zmiennych GLOBALNYCH, które do tej pory stosowaliśmy (Globalne to te
umieszczone jeszcze przed głównym programem, procedurami i funkcjami),
zmienna Lokalna jest "znana" TYLKO przez procedurę w której
została użyta (tzn. że każda procedura może mieć własne
zmienne, mogą się tak samo nazywać, ale ani główny program,
ani też żadna inna procedura nie może z nich korzystać
ponieważ ich nie zna, dlatego też mogą istnieć zmienne
Lokalne i Globalne o tej samej nazwie).
{2} Wyświetl lewy górny róg ramki
{3} Wyświetl lewy dolny róg ramki
{4} Wyświetl prawy górny róg ramki
{5} Wyświetl prawy dolny róg ramki
{6} Wyświetl linię górną
{7} Wyświetl linię dolną
{8} Wyświetl linię lewą
{9} Wyświetl linię prawą
Teraz przeanalizuj dokładnie linie {2}-{9} na jakiej zasadzie było
wykonane wyświetlanie tej ramki.
Oki czas zabrać się za główny temat tej lekcji "własnych
bibliotek". Najważniejszą rzeczą jest to aby NAZWA PLIKU W
KTÓREJ UMIESZCZONE JEST ŹRÓDŁO BIBLIOTEKI MIAŁO TAKĄ SAMĄ
NAZWĘ JAK BIBLIOTEKA ! Czyli jeżeli bibliotekę nazwiemy GIGIKURS
to jej źródło powinno się znajdować się w pliku
GIGIKURS.PAS a po skompilowaniu otrzymamy GIGIKURS.TPU (oczywiście ze względów
na to że nazwa pliku nie może mieć więcej niż 8 znaków
nie można utworzyć biblioteki "Moja_Fajna_Super_Biblioteka"
:)))))
Dobra dosyć marudzenia zabierzmy się za konkrety, będzie to
poprzedni program zamieniony na bibliotekę:
UNIT GIGIKURS; {1}
INTERFACE {2}
USES CRT,DOS,GRAPH; { GRAPH i DOS są wstawione od razu gdyż później będą nam potrzebne }
PROCEDURE WriteXY(x,y:byte; s:string); {3}
PROCEDURE Ramka(x1,y1,x2,y2:byte); {4}
IMPLEMENTATION {5}
PROCEDURE WriteXY(x,y:byte; s:string); {6}
Begin
GotoXY(x,y);
Write(s);
End;
PROCEDURE Ramka(x1,y1,x2,y2:byte); {7}
Var
t:byte;
Begin
WriteXY(x1,y1,chr(201));
WriteXY(x1,y2,chr(200));
WriteXY(x2,y1,chr(187));
WriteXY(x2,y2,chr(188));
For t:=x1+1 To x2-1 Do WriteXY(t,y1,chr(205));
For t:=x1+1 To x2-1 Do WriteXY(t,y2,chr(205));
For t:=y1+1 To y2-1 Do WriteXY(x1,t,chr(186));
For t:=y1+1 To y2-1 Do WriteXY(x2,t,chr(186));
End;
Begin {8}
End. {8}
{1} Definicja "oto nowa biblioteka o nazwie GIGIKURS". Linia
ta powinna znajdować się w źródle jako PIERWSZA.
{2} Definicja "teraz będą się znajdować opisy funkcji i
bibliotek które chcemy udostępniać w innych programach". Zwróć
uwagę że nie ma tutaj postawionego na końcu średnika.
{3,4} Informujemy kompilator, że w bibliotece tej znajdują się
procedury "WriteXY" oraz "Ramka". Są to linie TAKIE
SAME jak linie {6} i {7}
{5} Koniec definicji, teraz zaczynają się główne procedurki.
{8} Zobacz na to ! Pomiędzy "Begin" i "End." nic nie ma
! A to dlatego że to jest biblioteka, a nie program do uruchomienia. Po
skompilowaniu pascal utworzy plik GIGIKURS.TPU i w nim będą się
znajdować nasze dwie nowe procedury, a ponieważ jest to biblioteka to
definiuje się jej użycie tak jak i innych bibliotek w linii z USES :
USES CRT,GIGIKURS;
Begin
Clrscr;
Ramka(5,5,12,9);
End.
Przyznasz chyba że tak program wygląda
bardziej czytelnie :)
Procedury do obsługi
Myszki
Teraz utworzę procedury do obsługi
myszki, nie musisz znać ich działania na poziomie na którym teraz
jesteś, gdyż będę operował na przerwaniach więc
lepiej tego nie ruszaj :) , a ty mam nadzieję że sam dorzucisz je do
naszej biblioteki GIGIKURS.
PROCEDURE PokazMyche;
Var r:registers;
Begin
r.ax:=$0001;
Intr($33,r);
End;
PROCEDURE SchowajMyche;
Var r:registers;
Begin
r.ax:=$0002;
Intr($33,r);
End;
PROCEDURE UstawMyche(x1,y1,x2,y2:word);
Var r:registers;
Begin
r.ax:=$0007;
r.cx:=x1;
r.dx:=x2;
Intr($33,r);
r.ax:=$0008;
r.cx:=y1;
r.dx:=y2;
Intr($33,r);
End;
PROCEDURE PobierzMyche(var x,y,butt:word);
Var r:registers;
Begin
r.ax:=$0003;
Intr($33,r);
x:=r.cx;
y:=r.dx;
butt:=r.bx;
End;
PROCEDURE VgaOn;
Var
driver,mode:integer;
Begin
driver:=vga; mode:=vgahi;
InitGraph(driver,mode,'c:\bp\bgi'); { Tutaj wprowadz swoja sciezke do plikow BGI }
End;
Poszczególne procedury służą do:
PokazMyche - wyświetlenie myszki na ekranie
SchowajMyche - schowanie kursora myszki
UstawMyche - ustawienie minimalnych i maksymalnych wychyleń, w których
porusza się kursor myszki:
X1 - współrzędna X lewego górnego rogu
Y1 - współrzędna Y lewego górnego rogu
X2 - współrzędna X prawego dolnego rogu
Y2 - współrzędna Y prawego dolnego rogu
PobierzMyche - pobranie informacji o położeniu i stanie przycisków
myszki, zmienne:
X - współrzędna pozioma położenia
myszki
Y - współrzędna pionowa położenia
myszki
BUTT - informacja o wciśniętych klawiszach w
myszce:
1=lewy klawisz myszki
2=środkowy klawisz myszki
3=lewy+środkowy klawisz
myszki
4=prawy klawisz myszki
5=lewy+prawy klawisz myszki
6=środkowy+prawy klawisz
myszki
7=lewy+środkowy+prawy
klawisz myszki
VgaOn - to nie jest związane z mychą ale jest dość
przydatne, po prostu włącza tryb graficzny jedną linijką.
Teraz dwie żelazne zasady obsługi mychy:
Zasada 1. Jeżeli wykonasz po sobie N razy procedurę SchowajMyche, to
aby ukazał się kursor myszki należy wykonać również N
razy PokazMyche np.
[...]
PokazMyche; { myszka widoczna }
SchowajMyche; { myszka niewidoczna }
SchowajMyche; { myszka niewidoczna }
PokazMyche; { myszka NADAL NIEWIDOCZNA gdyż zostało użyte 2 razy ukrycie ! }
PokazMyche; { i dopiero teraz myszka widoczna }
[...]
Zasada 2. Jeżeli myszka znajduje się na ekranie i np.
narysujemy linię akurat przechodzącą przez kursor myszki, to część
linii, na której znajdował się wyświetlony kursor zostanie
skasowana tak więc sposobem na to jest wykonanie zawsze czegoś
takiego:
[...]
SchowajMyche; { Ukryj mychę aby kursor nie przeszkadzał }
Line(1,1,100,100); { Narysuj już teraz linię bez obaw że się coś skasuje }
PokazMyche; { Pokaż spowrotem myszkę }
[...]
Myszka w praktyce
Teraz będzie program ukazujący możliwości
nowych procedur, na początek prymitywny do włączenia trybu
graficznego i wyświetlenia kursora myszki :)
Uses CRT,GRAPH,GIGIKURS;
Begin
VgaOn;
UstawMyche(1,1,635,475); { aby lepiej to poznac poeksperymentuj z tymi wartosciami }
PokazMyche;
Repeat Until Keypressed;
CloseGraph;
End.
Extra ! Mycha
jest ! Nawet się rusza :) Ale co dalej ? Rozbudujemy na początek ten
program tak abyśmy widzieli na jakich współrzędnych znajduje się
aktualnie kursor myszki:
Uses CRT,GRAPH,GIGIKURS;
Var
x,y,przyciski:word;
tekstx,teksty:string;
Begin
VgaOn;
UstawMyche(1,1,635,475);
PokazMyche;
Repeat
PobierzMyche(X,Y,PRZYCISKI); {1}
SchowajMyche;
Str(X,tekstx); {2}
Str(Y,teksty); {3}
OutTextXY(10,10,tekstx); {4}
OutTextXY(10,30,teksty); {5}
PokazMyche;
Until Keypressed;
CloseGraph;
End.
{1} Pobranie współrzędnych położenia kursora mychy
( Działa nawet wtedy gdy nie widać kursora !)
{2-5} Zamiana wartości liczbowych współrzędnych X i Y na tekst
gdyż OutTextXY nie potrafi wyświetlać liczb i wyświetlenie
tych współrzędnych na ekranie.
No niby wyświetla tylko że jest jedna liczba na drugiej i całkiem
wszystko jest przez to zamazane, kolejnym krokiem będzie czyszczenie
miejsca pod liczbami:
Uses CRT,GRAPH,GIGIKURS;
Var
x,y,przyciski:word;
tekstx,teksty:string;
Begin
VgaOn;
UstawMyche(1,1,635,475);
PokazMyche;
SetFillStyle(SolidFill,Black); {1}
Repeat
PobierzMyche(X,Y,PRZYCISKI);
SchowajMyche;
Str(X,tekstx);
Str(Y,teksty);
Bar(10,10,40,40); {2}
OutTextXY(10,10,tekstx);
OutTextXY(10,30,teksty);
PokazMyche;
Until Keypressed;
CloseGraph;
End.
{1} Ustawienie koloru wyświetlania wypełnionego prostokąta
na czarny
{2} Narysowanie prostokąta i zamazanie przez to liczb "pod nim"
się znajdujących
Coraz lepiej :) Tylko to migotanie wszystkiego :( Rozwiązać to można
tak:
Uses CRT,GRAPH,GIGIKURS;
Var
x,y,przyciski:word;
staryx,staryy:word; {1}
tekstx,teksty:string;
Begin
VgaOn;
UstawMyche(1,1,635,475);
PokazMyche;
SetFillStyle(SolidFill,Black);
staryx:=1000; {2}
Repeat
PobierzMyche(X,Y,PRZYCISKI);
If (staryx<>x) OR (staryy<>y) Then {3}
Begin
SchowajMyche;
Str(X,tekstx);
Str(Y,teksty);
Bar(10,10,40,40);
OutTextXY(10,10,tekstx);
OutTextXY(10,30,teksty);
Staryx:=x; {4}
Staryy:=y; {5}
PokazMyche;
End;
Until Keypressed;
CloseGraph;
End.
{1} nowe zmienne będące informacją
"w jakim położeniu znajdował się poprzednio
kursor"
{2} wstawiam liczbę 1000 do zmiennej STARYX, aby już na samym początku
wywołać wyświetlenie współrzędnych myszki, a dokonuję
tego w ten sposób: ponieważ początkowo X=0 a gdy STARYX=1000 to w
linii {3} zostanie spełniony warunek wyświetlania.
{3} jeżeli zmieniło się położenie kursora ( zmienił
się X lub Y ) to wyczyść miejsce pod tekst i wyświetl
aktualne współrzędne.
{4,5} utrwal aktualne położenie kursora w zmiennych
No popatrz ! Już jest wszystko oki ! Nic nie mruga :) Teraz dla wprawy
wstaw jedną linijkę z PutPixel tak, aby można było "rysować" pixelkami na ekranie (
nie będzie to porażająca prędkość, rzekłbym
nawet że tragiczna więc się zbytnio nie przejmuj :)
Wybieranie Myszką Obiektów
Powinieneś już co nieco rozumieć
z obsługi mychy, zajmiemy się jeszcze na tej lekcji wybieraniem obiektów
np. przycisków. Narysujmy więc na początek trzy proste ikonki:
USES CRT,GRAPH,GIGIKURS;
Begin
VgaOn;
SetFillStyle(SolidFill,Green);
Bar(215,220,275,250);
Bar(285,220,345,250);
Bar(355,220,415,250);
OuttextXY(218,232,'Opcja 1');
OuttextXY(288,232,'Opcja 2');
OuttextXY(358,232,'Opcja 3');
Repeat Until Keypressed;
CloseGraph;
End.
Dorzućmy do tego obsługę myszki z poprzedniego programu
wycinając niepotrzebne już linie wyświetlające współrzędne:
Uses CRT,GRAPH,GIGIKURS;
Var
x,y,przyciski:word;
Procedure OPCJA1;
Begin
Sound(50);
End;
Procedure OPCJA2;
Begin
Sound(100);
End;
Procedure OPCJA3;
Begin
Sound(150);
End;
|
