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:

SHORTINT (-128..127) 1 bajt
INTEGER (-32768..32767} 2 bajty
LONGINT {-2147483648..2147483647} 4 bajty
BYTE {0..255} 1 bajt
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 !

Deklaracja Stałych

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)

Biblioteki (moduły) deklaruje się słowem kluczowym "Uses":

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".

Używanie Średnika

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: ":=" i przykładowo jeżeli zmiennej ABC typu WORD ( liczba przypisywana MUSI znajdować się w zakresie typu tej zmiennej ) chcemy nadać wartość 456 to piszemy: "ABC:=456;". Niektórych może zaintrygować dlaczego instrukcję przypisania zapisuje się tak ":=" zamiast zwykłego znaku równości "=" ? Zobacz na przykładzie: operacja "kolejna:=kolejna+1" z punktu widzenia matematyki może wydawać się błędna i to wygląda jak np. "4=4+1" co jest absolutną bzdurą, to my wykonujemy tu jednak nie równanie matematyczne, a nadanie zmiennej nowej wartości, aby to wyjaśnić zobacz jak taką linię postrzega komputer: najpierw sumowane jest to co znajduje się po prawej stronie, a dopiero potem podstawiane jest do zmiennej po lewej np. zmienna "kolejna" ma wartość 2, wykonujemy prawą stronę "2+1" komputer zapamiętuje sobie tam gdzieś u siebie w pamięci "3" ( wynik równania ) i dopiero potem wykonuje lewą stronę "kolejna:=liczba z pamięci"

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.

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.
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 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.

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.

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.

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.

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.

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.

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.

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

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.

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.

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 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

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 !

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.

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.

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

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

Wzór - 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;
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 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.

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.

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.

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 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 Funkcji

Funkcje są podobne w tworzeniu do procedur z tym, że funkcja zazwyczaj zwraca pewną wartość. Przykładowymi funkcjami są np. pierwiastkowanie, sinus, cosinus ( funkcja nie musi koniecznie zwracać liczby, może to być każdy z typów zmiennych, np. char z ReadKey ).

Zrobimy sobie teraz prostą funkcję, która będzie nam zwracała kod wciśniętego klawisza z tym, że jeżeli to będzie klawisz rozszerzony to kod ten zostanie pomnożony przez 256. Dzięki temu klawisze zwykłe będą miały zawsze kody poniżej 255 a rozszerzone powyżej.

Uses CRT;
Var
kl:word;
FUNCTION GetKey:word; {1}
Var
a1,a2:Char;
Begin
Repeat Until Keypressed; {2}
a1:=ReadKey; {3}
If a1=Chr(0) Then a2:=ReadKey; {4}
If a1<>Chr(0) Then GetKey:=Ord(a1) Else GetKey:=256*Ord(a2); {5}
End;
Begin
Repeat
kl:=GetKey; {6}
WriteLn(kl); {7}
Until kl=27; {8}
End.

{1} zdefiniuj funkcję GetKey
{2} czekaj na wciśnięcie klawisza
{3} podstaw pod zmienną a1 wciśnięty klawisz
{4} jeżeli to był klawisz rozszerzony to podstaw go pod zmienną a2
{5} jeżeli to nie był klawisz rozszerzony to zwróć w funkcji kod ASCII znaku, w przeciwnym wypadku zwróć w funkcji kod klawisza rozszerzonego pomnożonego przez 256.
{6} pobierz kod klawisza
{7} wyświetl go
{8} powtórz aż zostanie wciśnięty klawisz ESCAPE

Zobacz teraz, na jakiej zasadzie jest zwracana wartość funkcji, a dzieje się to w linii {5}. Do nazwy funkcji jest podstawiana liczba, która mieści się w zakresie typu word. A musi się w nim mieścić gdyż zadeklarowaliśmy w linii {1}, że właśnie taki typ zwróci nam funkcja.

Procedura GetDate

Składnia: GetDate(var Rok, Miesiac, Dzien, DzienTygodnia:word); biblioteka: DOS
Procedura pobierająca aktualną datę systemową. Poszczególne zmienne mogą zawierać wartości:

Rok : 1980 – 2099
Miesiac : 1 – 12
Dzien : 1 – 31
DzienTygodnia - 0 - 6 ( 0 = niedziela, 1 = poniedziałek, ... , 6 = sobota )

Tak więc z tego widać, że Pascal jest odporny na problem roku 2000 :)

Przykładowy program:

Uses DOS;
Const
dni:array[0..6] of string=('Niedz','Pon','Wto','Sro','Czw','Pia','Sob'); {1}
Var
rok,mies,dzien,dztyg:word;
Begin
GetDate(rok,mies,dzien,dztyg);
WriteLn('Dzisiejsza Data : ',dni[dztyg],' ',dzien,'-',mies,'-',rok);
End.

Wynik tego programu to np.
Dzisiejsza Data : Sob 9-10-1999