2012
/
Podstawy
Programowania
Na przykładach w języku Turbo Pascal
Szybki kurs podstaw programowania w oparciu o programowanie strukturalne
w języku Turbo Pascal. Zawiera proste i klarowne wyjaśnienia podstawowych
poleceń spotykanych we wszystkich językach oraz przykładowe kody i zadania.
Kurs zaawansowany (rozszerzenie) oraz kurs programowania obiektowego w
przygotowaniu.
M.Woliński
KAZA© Corp.
2012-07-05
Spis Treści
Rolą wstępu, czyli co to jest program ....................................................... 3
Jak rozmawiać z kompilatorem? .............................................................. 4
Tworzymy nowy program ........................................................................ 5
Zmienne i typy zmiennych........................................................................ 6
Zadania ...................................................................................................... 7
Warunek if& . ........................................................................................... 8
& oraz polecenia Or, And, Not ...................................................................8
Zadania ...................................................................................................... 9
Instrukcja wyboru CASE ..........................................................................10
Zadania ....................................................................................................10
Pętle FOR/REPEAT/WHILE .......................................................................11
Zadania ....................................................................................................11
Procedury ...............................................................................................12
Zadania ....................................................................................................13
Funkcje ...................................................................................................14
Funkcje Proste .........................................................................................14
Funkcje Rekurencyjne .............................................................................14
Zadania ....................................................................................................15
Biblioteki.................................................................................................16
CRT ..........................................................................................................16
DOS .........................................................................................................16
DLL ..........................................................................................................17
Przykładowe Programy ...........................................................................18
Kalkulator ................................................................................................18
Tworzenie Ścieżki (Katalogów) ................................................................18
Menu Główne..........................................................................................19
Kalkulator Kredytowy ..............................................................................19
Rolą wstępu, czyli co to jest program
Wiele osób chcąc nie chcąc zetknęło się i to nie raz z programami. Czy to w pracy, w
domu czy w szkole, kontakt z komputerem jest nie unikniony, a co za tym idzie i z
programami. W niniejszej książce pokażę Państwu jak skutecznie tworzyć własne programy,
dzięki czemu będą mogli państwo dostosować świat komputera do siebie a nie na odwrót.
Program jest to zestaw poleceń (instrukcji) dla procesora wykonywanych w celu
uzyskania jakiegoś efektu. Aby program mógł zaistnieć w komputerze musi być zrozumiały
dla procesora, a co za tym idzie komunikować się w formie zer i jedynek. Pisanie programów
w ten sposób jest uciążliwe i wyjątkowo nieefektywne, dlatego przydaje się kompilator.
Kompilatory są to pewnego rodzaju tłumacze pośredniczące pomiędzy użytkownikiem, a
komputerem. Większość kompilatorów zostało zrobionych w języku angielskim i rozpoznaje
podstawowe słowa takie jak IF (jeżeli), END (koniec), EXIT (wyjście), itp. Dzięki
kompilatorowy możliwe jest szybkie przekształcenie języka pisanego na system zer i jedynek.
Każdy kompilator posługuje się jednym (bądz
kilkoma) dialektami nazywanymi językami
programowania. Tak jak Brytyjczycy piszą  cannot , a amerykanie  can t mając na myśli to
samo, tak samo języki programowania różnią się poleceniami dającymi ten sam efekt. Wybór
odpowiedniego języka oraz kompilatora jest bardzo ważny, dlatego warto poświęcić mu
nieco czasu. Z uwagi na prostotę języka wszelkie przykłady zostaną napisane w języku Turbo
Pascal. Jeśli nie wiesz jaki wybrać język i kompilator, lub dopiero zaczynasz przygodę z
programowaniem proponuję również zacząć od najprostszego. Kompilator Turbo Pascala
można pobrać ze strony: www.darmoweprogramy.org/394/Dev-Pascal.
Jak rozmawiać z kompilatorem?
Komunikacja z kompilatorem wykorzystuje kilka podstawowych zwrotów podzielonych
na kategorie. Pewne polecenia sÄ… wykonywane jako pierwsze inne jako ostatnie, ale
wszystkie składają się ze znaków. Oto podstawowy zestaw poleceń:
Rodzaj Opis Polecenie
Arytmetyczne Dodawanie +
Odejmowanie -
Mnożenie *
Dzielenie /
Reszta z dzielenia mod
Dzielenie całkowite div
Logiczne Albo or
Oraz and
Nie not
Tylko jedno z xor
Relacyjne Większe >
Mniejsze <
Równe =
Różne <>
Większe lub równe >=
Mniejsze lub równe <=
Orientacyjne PoczÄ…tek begin
Koniec end
Każde z powyższych poleceń jest poleceniem podstawowym i nie wynika z niego żadna
akcja. Jednakże tworząc każde polecenie złożone potrzebna będzie znajomość poleceń
podstawowych, które będą wchodzić w skład innych poleceń.
Tworzymy nowy program
Aby utworzyć nowy program wystarczy wykonać kilka prostych kroków. Po
uruchomieniu programu Dev-Pas.exe tworzymy nowy projekt klikajÄ…c na ikonÄ™ w
lewym górnym rogu. Wyświetli się okno komunikatu z zapytaniem o rodzaj
projektu. Na poczÄ…tek wybieramy  konsole aplication , wybieramy miejsce
zapisu i już mamy gotowy program. Na razie nie wykonuje on jeszcze żadnych poleceń, ale
dzięki kompilatorowi zaczął on już istnieć. Przyjrzyjmy się z czego składa się nasz program.
Treść naszego programu składa się z trzech linijek. W pierwszej linii znalazło się
polecenie  program untitiled1; . Polecenie to będzie otwierało każdy program, gdyż
najzwyczajniej informuje kompilator, że od tego miejsca zaczyna się treść programu, oraz
nadaje mu nazwę. W tym wypadku jest to  untitiled1 . W to miejsce można wpisać własną
nazwę. Należy tylko pamiętać aby zakończyć znakiem  ; [średnik]. Średnik informuje
kompilator o końcu polecenia. Niemal wszystkie polecenia kończą się średnikiem. Wyjątek
stanowi koniec programu oznaczony znakiem  . [kropka].
Drugą linię stanowi słowo Begin. Oznacza on początek pewnego rozdziału. Wszystkie
następujące po nim polecenia kompilator będzie traktował jako nierozerwalną całość, aż do
słowa end. Jako że jest to pierwsze takie polecenie w naszym programie kompilator uzna
wszystko pomiędzy słowami  Begin , a  end za główną treść naszego programu. To tutaj
znajdą się polecenia, które będą miały dać jakiś widoczny efekt. Spróbujmy go wywołać
używając poleceń writeln oraz readln. Zaraz za słowem Begin wpiszmy:
writeln( Hello World );
readln();
Polecenie writeln spowoduje wyświetlenie zawartości nawiasu. W tym wypadku jest to tekst
Hello World. Warto zwrócić uwagę na fakt, że tekst, który nie jest poleceniem w turbo
pascal u umieszcza się pomiędzy apostrofami. Natomiast polecenie readln każe programowi
czekać na sygnał z klawiatury. Nawias za tym polecenie pozostawiamy pusty, ponieważ to co
zostanie wpisane nas zwyczajnie nie interesuje. Teraz w zakładce  execute wybieramy opcję
 Compie . To samo polecenie można znalez
ć na pasku narzędzi. Teraz kompilator
wprowadził zmiany do naszego programu. Aby zobaczyć efekty wybieramy przycisk execute.
Powinniśmy zobaczyć okno z czarnym tłem i białym napisem  Hello World . Napisaliśmy nasz
pierwszy program.
Zmienne i typy zmiennych
Zmienne w języku Turbo Pascal zapisuje się po słowie kluczowym VAR. Zmienna jest to
reprezentacja pamięci w programie. Innymi słowy, jeśli program to biurko, to zmienne są
kartkami na biurku. Każda zmienna musi mieć nazwę poprzez którą kompilator będzie ją
identyfikował, oraz mieć przypisany typ. Istnieje kilka podstawowych typów. Są to:
integer(liczba całkowita), Real(liczba rzeczywista), string(łańcuch znaków) oraz
boolean(prawda lub fałsz). Deklaracja zmiennych wygląda następująco:
VAR
imie,nazwisko: string;
wiek:integer;
srednia:Real;
W ten właśnie sposób zadeklarowane zostały cztery zmienne. Deklaracja zmiennych
nie jest poleceniem, ale informacją więc musi nastąpić przed pierwszym słowem Begin, i
opisane w ten sposób zmienne będą rozpoznawalne aż do końca programu. Jeśli chcemy
zadeklarować kilka zmiennych posiadających ten sam typ możemy wymienić je po przecinku,
tak jak imie i nazwisko. Ogólny schemat deklaracji wygląda następująco:
<>,<>,..,<>:<>;
Korzystając ze zmiennej możemy zapisać na niej pewne informacje, tak by program pamiętał
o nich. W tym celu używa się dwuznaku  := . Takie polecenie nazywa się przypisaniem. Oto
kilka przykładów przypisania:
wiek:=3;
imie:= Jan ;
nazwisko:=imie;
Błędem byłoby jednak przypisanie  imie:=3 . Z uwagi na brak apostrofów kompilator uznałby
3 liczbą i nie pozwoliłby na zapisanie jej na zmiennej przechowującej łańcuch znaków. Teraz
znając już zasady operacji na zmiennych możemy użyć procedury readln(); . Aby program
zapamiętał to co użytkownik wpisuje na klawiaturze wystarczy wpisać polecenie
readln(<>); przykładowo readln(imie);. Od tego momentu za każdym razem gdy
wpiszemy imie program użyje otrzymanych wtedy od użytkownika danych. Aby wyświetlić je
na ekranie wystarczy wpisać polecenie writeln();. Na przykład Writeln(Imie);.
Dodatkowo zmienne typu string traktowane są w sposób specjalny. Możliwe jest
odwołanie się do poszczególnych znaków w łańcuchu. W naszym przypadku: imie[2] =  a .
Można to wykorzystać przy tworzeniu podpisów. Jeśli użyjemy przypisania:
Imie:= Jan ;
Nazwisko:= Nowak ;
Podpis:=imie[1]+ .  +nazwisko;
Write(Podpis);
Na ekranie otrzymamy  J. Nowak .
Zadania
Zad1
Program zagadka;
var
imie:string;
Begin
imie:= 2 ;
imie:= Kasia ;
imie:= Michał ;
writeln(imie);
readln();
end.
Jaki napis pojawi siÄ™ na ekranie po skompilowaniu takiego programu?
Zad2
Napisz program  echo , który będzie powtarzał to co wpisze użytkownik.
Zad3
program mat;
var
a:integer;
begin
a:=1;
a:=a+1;
writeln(a+1);
readln();
end.
Sprawdz
jaka liczba wyświetli się po wykonaniu tego programu, a jaką wartość ma
zmienna a.
Warunek if& .
Warunki są podstawą działania programów. Za każdym razem, gdy rodzaj działanie
będzie wymagał podjęcia decyzji będziemy używać polecenia IF. Ma ono następującą
składnię:
IF (warunek) then polecenie else polecenie;
Warunek musi być jasno określony, tzn. musi jednoznacznie być prawdą albo fałszem.
Warunkiem nie może być np. 2, ale 2=3 to już sensowny warunek, ponieważ można określić
go jako fałsz. Po słowie kluczowym then wpisujemy polecenie, które ma być wykonane w
przypadku prawdziwości warunku, a po słowie else polecenie na wypadek fałszu. Przykłady:
if (2=2) then a:=2; znaczy  jeżeli 2=2 to wtedy niech a stanie się 2
if (a=2) then a:=3 else a:=2; znaczy  jeżeli a=2 to wtedy niech a stanie się 3, a jeśli nie to
niech a stanie siÄ™ 2
Aby jeszcze trochę rozjaśnić sytuację napiszmy program, który się z nami przywita.
Zaczynamy, a więc:
program witaj;
var
s:string;
Begin
readln(s);
if (s= Witaj. ) then writeln( Witaj. );
readln();
end.
Ten program odpowie nam jeśli tylko napiszemy do niego  Witaj. , ale gdy będziemy
do niego pisać cokolwiek innego (np. cześć) już nie. Warto go więc ulepszyć.
& oraz polecenia Or, And, Not
Zamieńmy polecenie  if&  na  if (s= Witaj. ) OR (s= Witaj ) then writeln( Witaj. );
dzięki temu nasz program odpowie, nawet gdy ominiemy kropkę. Spróbuj teraz samemu
dodać kilka warunków, tak aby program odpowiadał także na np. Dzieńdobry.
Polecenia Or, And, Not są poleceniami ustalającymi zależność pomiędzy warunkami.
Dzięki nim kompilator wie jaka jest waga każdego z nich. Jeśli zapiszę  2=2 and not 2=3
znaczy to, że program musi sprawdzić obydwa warunki. My jednak wiemy, że nie ma takiej
potrzeby więc wystarczy wpisać  2=2 or not 2=3 . W takim układzie program wie, że
wystarczy mu sprawdzić poprawność dowolnego z warunków, i gdy prawdziwe będzie, że
2=2 nie będzie już się zastanawiał czy 2 nie jest równe czasem 3. Czasem używanie tych
poleceń wymaga użycia dodatkowych nawiasów, dlatego zaleca się aby w jednym nawiasie
nie było więcej niż 2 warunków. Bezpieczniej zapisać jest
(a=2 and b=2) Or (a=b) niż (a=2 and b=2 Or a=b).Spróbujmy w oparciu o polecenia if napisać
prosty kalkulator. Jako zmiennych będziemy potrzebować dwóch liczb, oraz zmiennej
tekstowej jako działania. (znak  + nie jest liczbą). W pierwszej kolejności odczytujemy
działanie, a następnie 2 liczby. I co dalej? Dalej 4x IF. Dla działań +,-,*,/.
If (dzialanie= + ) then writeln(a+b);
If (dzialanie= - ) then writeln(a-b);
itd.
Wyjątkiem będzie działanie dzielenia, które będzie wymakało polecenia AND. Działanie
dzielenia ma na klawiaturze 3 znaki: /, \, /. Należy pamiętać, że kompilator rozróżnia znaki z
klawiatury alfa-numerycznej i numerycznej. Dlatego też znak  / ma dwie wersje.
Zadania
Zad1
Napisz program który będzie dzielił przez 2 tylko liczby parzyste, a nieparzyste mnożył.
Zad2
Napisz program który będzie zamieniał wszystkie liczby na dodatnie.
Zad3
Popraw poniższy kod tak, aby powstało jedno zagnieżdżone polecenie if.
Program Zadanie;
Var
x,y:integer;
Begin
Readln(x);
Readln(y);
If x>y then writeln( X jest większe );
If x If x=y then writeln( X jest równe Y );
end;
Instrukcja wyboru CASE
Instrukcja case jest to zestaw odpowiednio skonstruowanych warunków typu if. Ma
ona jednak pewne ograniczenie. Mianowicie działa tylko w oparci u zależność równości. Jej
ogólny schemat wygląda następująco:
case zmienna of
wartość1:polecenie;
wartość2:polecenie;
wartość3:polecenie;
end;
Jest to o wiele prostszy sposób zapisu kilku warunków według tego samego schematu
if-then. Dodatkowo tak sformatowany kod może lepiej odzwierciedlać np. menu. Niestety
przy jej pomocy nie sprawdzimy np. która z 3 liczb jest największa.
Zadania
Zad 1
Zamień poniższe warunki if na jedną instrukcję case.
If d= + then a:=a+b;
If d= - then a:=a-b;
If d= * then a:=a*b;
If d= / then a:=a/b;
Zad 2
KorzystajÄ…c z zapisanej instrukcji napisz prosty kalkulator.
Pętle FOR/REPEAT/WHILE
Pętle jak sama nazwa wskazuje zawierają polecenia, które zapętlają się czyli są
wykonywane aż do jakiegoś warunku. Najprostszą i najczęściej używaną jest pętla FOR. Pętla
ta wykonuje pewne poleceni w oparciu o jakąś liczbę zwiększając jej wartość. Polecenie For
i:=1 to 10 do writeln(i); będzie wypisywać liczby zaczynając od 1 i zwiększając ją o 1 po
każdym wypisaniu. Pętla zakończy działanie gdy liczba ta wyniesie 10. Przyjrzyjmy się
konstrukcji. Pierwszym słowem kluczowym jest słowo FOR. Polecenie to informuje
kompilator o początku pętli. Następnie następuje polecenie przypisania i:=1, która wskazuje
od jakiej wartości pętla zaczyna. Jako aktualnie wykorzystywaną liczbę kompilator będzie
używał zmienną i. Następnie pojawia się jedno z dwóch poleceń. TO albo DOWNTO.
Określają one kierunek pętli, tzn. czy zmienna i ma się zwiększać czy zmniejszać.
Jak już pewnie zauważyłeś przydatna jest tu znajomość języka angielskiego. Ponieważ
większość firm informatycznych ma swoje korzenie w stanach pomoce to tworzenia
produktów (czyli także programów) są w języku angielskim. Zwrot downto tłumaczymy jako
 w dół do . Tak więc pętla For i:=1 downto 5 do; nigdy się nie zakończy, ponieważ idąc w dół
od jeden nigdy nie natrafimy na 5.
Jeżeli koniec pętli nie zależy od liczby najlepiej użyć pętli warunkowej repeat albo
while. Pętla repeat powtarza daną czynność aż do spełnienia warunku umieszczonego na
końcu. Pętla while wykonuje czynności jeżeli warunek zawarty na początku jest spełniony.
Widzisz różnicę? Pętla repeat zostanie wykonana co najmniej raz, bez względu na
prawdziwość warunku, pętla while najpierw sprawdzi poprawność warunku. A teraz
przykłady:
i:=0;
i:=0;
while (i=1) doi:=1;
Repeat
i:=1;
until (i<>1);
Jak zapewne widzisz pierwsza pętla będzie wykonywana w nieskończoność, natomiast
druga nie zostanie wykonana nigdy. Różnica ta jest bardzo przydatna w czasie komunikacji z
użytkownikiem. Pętli while używa się gdy chce się od użytkownika pobierać dane
określonego typu, np. liczby. Pętli repeat używa się np. w oczekiwaniu na konkretne
zdarzenie.
Zadania
Zad1.
Napisz program który będzie mnożył podaną liczbę przez 2 aż nie przekroczy ona 26.
Spróbuj użyć różnych pętli.
Zad2.
Napisz program który będzie odczytywał znaki z klawiatury, tak długo aż nie zostanie
podana cyfra.
Procedury
Procedury są to elementy kodu, które mogą działać niezależnie od całościprogramu.
Podstawową ideą jest możliwość kopiowania całych sekcji bez konieczności sprawdzana
zgodności zmiennych. Najprostszym przykładem jest procedura writeln. Można ją zapisać
jako zbitek procedury write oraz zakończenia linii. Ogólny schemat zapisu procedury wygląda
następująco:
Procedure nazwa (par1: typ; par2: typ);
begin
lista poleceń
end;
Tak zapisaną procedurę należy wstawić przed początkiem kodu programu (pomiędzy
sekcją var a głównym begin. Od tego momentu za każdym razem kiedy wpiszemy jako
polecenie nazwÄ™ naszej procedury, zostanÄ… wykonane polecenia w niej zawarte. Procedur
mogą składać się z dowolnej ilości poleceń, które nie wymagają korzystania ze zmiennych
globalnych, czyli głównych zmiennych programu. Zmienne zadeklarowane wewnątrz
procedur nazywamy lokalnymi i sÄ… one rozpoznawane tylko wewnÄ…trz procedury. Czas na
wykorzystanie teorii w praktyce. Stwórzmy procedurę wyświetlającą podpis pewnej osoby.
Procedure Podpis(imie: string; nazwisko: string);
Var
Temp: string;
Begin
Temp:=imie[1]+ .  +nazwisko;
Write(Temp);
end;
Tak skonstruowana procedura może być użyta dla różnych danych. Przykładowo:
" Nowak
" K. Janda
" M. Wiśniewski
Może też być używana wielokrotnie co znacznie skraca ilość kodu potrzebną do
zapisania programu. Dzięki takim zabiegom można znacznie uprościć i skrócić pisanie
programów. Dodatkowo wewnątrz procedur mogą być umieszczane kolejne pod warunkiem,
że ich deklaracja już wcześniej wystąpiła. Przykładowo:
Procedure Linia();
Var
i:byte;
Begin
For i:=1 to 20 do Write(   );
Writeln();
End;
Procedure Podpis(imie: string; nazwisko: string);
Var
Temp: string;
Begin
Temp:=imie[1]+ .  +nazwisko;
Linia();
Write(Temp);
Linia();
end;
W ten sposób dzielimy program na podprogramy, które działając niezależnie mogą być
modyfikowane i ulepszane bez znajomości całości kodu, co jest szczególnie przydatne
podczas dużych projektów. Kiedy kilka osób pracuje nad jednym programem może tworzyć
takie właśnie procedury, które potem składa się w gotowy program.
Zadania
Zad 1.
Przy pomocy procedur napisz kalkulator. Postaraj się wykorzystać pętle, tak aby nie
trzeba było uruchamiać go kilkakrotnie.
Zad 2
Napisz program, który będzie wyświetlał dowolny tekst w ramce. Użyj co najmniej
dwóch procedur.
Zad 3
Popraw poniższy kod, tak aby powtarzające się elementy były procedurami.
Program Kalkulator
Var
x,y,z,i: integer;
d: char;
Begin
Write( Wtaj. Podaj pierwsza liczbe. ); Readln(x);
Write( Podaj druga liczbe. ); Readln(y);
Write( Podaj trzecia liczbe. ); Readln(z);
Repeat
Write( Podaj pierwsze dzialanie (+/-) ); Readln(d);
Until((d= + ) OR (d= - ));
If d= + then x:=x+y;
If d= - then x:=x-y;
Repeat
Write( Podaj drugie dzialanie (+/-) ); Readln(d);
Until((d= + ) OR (d= - ));
If d= + then x:=x+z;
If d= - then x:=x-z;
Write ( Wynik to:  , x);
End.
Funkcje
Funkcje Proste
Funkcje, jest to rozbudowana forma procedur. Ogólny schemat deklaracji funkcji
wygląda następująco:
Function Nazwa(Par1: typ; Par2: typ):typ
begin
ciąg poleceń
end;
Jak można łatwo zauważyć, funkcje mają pewien typ. Typ funkcji jest to rodzaj wartości
oddanej do systemu po zakończeniu jej działania. Może on być dowolny, choć najczęściej
spotykany to boolean (logiczny). Funkcje, w przeciwieństwie do procedur, mogą być
używane jako parametry innych funkcji (albo procedur). W ten sposób można łączyć
działanie kilku funkcji według schematu: Jeżeli pierwsza funkcja wykonała się poprawnie,
rozpocznij następną, inaczej wyświetl komunikat błędu. Funkcje są szeroko wykorzystywane
ze względu na możliwość zwracania wartości, bez użycia dodatkowych zmiennych.
Oto kilka przykładów użycia funkcji:
Program Przyklad;
Var
x:string;
Function Podpis(imie: string; nazwisko: string):string;
Var
Temp: string;
Begin
Temp:=imie[1]+ .  +nazwisko;
Podpis:=Temp;
end;
Begin
Writeln(  Być albo nie być  ,Podpis( Wiliam , Shakespeare );
x:=Podpis( Jan , Nowak );
Writeln( Przekład:  ,x);
End.
Funkcje Rekurencyjne
Funkcje rekurencyjne są to takie funkcje, które odwołują się do samych siebie.
Najprostszym i najczęściej podawanym przykładem jest silnia. Wyrażenie 5! Oznacza tyle co
5x4x3x2x1. Aby jak najprościej przedstawić to językiem programowania należy zauważyć
pewną zależność. 4x3x2x1=4!, a więc 5!=5x4!, czyli inaczej 5x(5-1)!. W ten sposób opisuje się
funkcje rekurencyjne:
A!=
Ax(A-1)! dla A>0;
1 dla A=0;
W języku programowania wyglądałoby to następująco:
Function Silnia(x:integer):integer;
Var
Temp:integer;
Begin
If x=0 then temp:=1 else temp:=Silnia(x-1);
Silnia:=temp;
End;
W ten prosty sposób działanie, które należałoby zapisać w pięciu bądz
więcej liniach
zmieściliśmy w dwóch poleceniach. Funkcje rekurencyjne z uwagi na krótki kod często
optymalizują (przyspieszają) pracę programu, co przy dużych i skomplikowanych obliczeniach
daje realne korzyści.
Zadania
Zad 1
Napisz kalkulator z wykorzystaniem funkcji. Porównaj kod z kalkulatorem opartym na
procedurach.
Zad 2
Spróbuj opracować funkcję rekurencyjną dla potęgowania.
Biblioteki
Biblioteki sÄ… to zestawy komend zwiÄ…zane z konkretnym rodzajem programu. Do
najpopularniejszych należą DOS oraz CRT. Biblioteka CRT zawiera procedury i funkcje
związane z wyświetlaniem (prezentacją) danych, natomiast biblioteka DOS zawiera wybrane
polecenia MS-DOS.
Aby dołączyć wybraną bibliotekę do swojego programu należy wpisać jej deklarację na
poczÄ…tku programu. Np.:
Program Przykład;
uses crt;
CRT
Najczęściej używane polecenia biblioteki crt to:
" TextColor(cl: byte)
" TextBackground(cl: byte)
" clrcsr
Polecenie TextColor zmienia kolor wyświetlanego tekstu na jeden z 16 dostępnych.
Jako wartość podaje się liczbę od 0 do 15. Polecenie TextBackground zmienia kolor tła pod
wyświetlanym tekstem. Procedura clrscr czyści ekran z tekstu. No dobrze. Ale jak zmienić
kolor tła na całym ekranie? Jest na to pewien prosty sposób. Najpierw używamy procedury
TextBackground, a następnie polecenia clrscr. W ten sposób cały ekran pokryje nam się
wybranym kolorem. Obydwie procedury są bardzo przydatne ze względu na kontakt z
użytkownikiem. Komunikaty ostrzeżeń mogą być wyświetlane na żółto, a komunikaty błędów
na czerwono.
DOS
Biblioteka DOS zawiera głównie polecenia związanie z zarządzaniem katalogami jak na
przykład: mkdir  tworzy katalog oraz rmdir  usuwa katalog. Pełna lista dostępnych poleceń
dla różnych bibliotek dostępna jest w Internecie.
DLL
Rozszerzenia programów (dll) zawierają funkcje pogrupowane według pewnego
schematu. Można z nich korzystać bez znajomości wszystkich procesów, które w nich
zachodzą. Aby wywołać jakąś funkcję z rozszerzenia należy ją najpierw zadeklarować przed
głównym blokiem programu.
Function My_Func1(); external  roz1.dll ;
W ten sposób funkcja ta zostanie zaczerpnięta z rozszerzenia o nazwie roz1.dll w
głównym katalogu programu.
Przykładowe Programy
Poniżej zamieszczono przykłady rozwiązań niektórych problemów oraz jeden duży
program jako przykład wykorzystania możliwości rozszerzeń DLL.
Kalkulator
Program Kalkulator
Uses crt
Var
x,y,i: integer;
d: char;
Begin
TextColor(10);
ClrScr;
Write( Wtaj. Podaj pierwsza liczbe. ); Readln(x);
Write( Podaj druga liczbe. ); Readln(y);
Repeat
Write( Podaj dzialanie (+/-) ); Readln(d);
Until((d= + ) OR (d= - ));
If d= + then x:=x+y;
If d= - then x:=x-y;
Write ( Wynik to:  , x);
End.
Tworzenie Ścieżki (Katalogów)
function DirCreate(path:string):boolean;
var
tmp:boolean;
s,Stmp:string;
i:integer;
begin
tmp:=false;
s:=path;
tmp:=DirectoryExists(s);
repeat
if s[length(s)] = '\' then
begin
for i:=1 to length(s)-1 do Stmp:=Stmp+s[i];
tmp:=DirectoryExists(s);
end
else
for i:=1 to length(s)-1 do Stmp:=Stmp+s[i];
s:=Stmp;
Stmp:='';
until(tmp = true);
i:=length(s)+1;
s:=s+'\';
 repeat
while ((path[i+1]<>'\') AND (s<>path)) do
begin
s:=s+path[i+1];
i:=i+1;
end;
if path[i+1]='\' then
begin
mkdir(s);
s:=s+'\';
end;
i:=i+1;
until (s=path);
mkdir(s);
DirCreate:=True;
end;
Menu Główne
procedure MENU(var c:char); export;
begin
clrscr;
writeln('MENU: ');
writeln('Draw (d) ');
writeln('Print (p) ');
writeln('Load (l) ');
writeln('Save (s) ');
writeln('Help (h) ');
writeln('New (n) ');
writeln('Exit (x) ');
writeln;
writeln('Press the choosen key...');
c:=readkey;
end;
Kalkulator Kredytowy
program Kalkulator;
uses crt,dos;
const
//text and titles
headline_text = 'PLAN SPLATY KREDYTU';
//positions and colors
back_defoult = 3;
back_choice = 6;
back_alert = 4;
text_defoult = 11;
text_choice = 14;
text_alert = 12;
hotkey = 15;
pos_alertX = 12;
pos_alertY = 6;
//time menager values
speed = 50;
type
 kredyt = object
value:double;
time:word;
height:double;
procedure raty(); forward;
procedure malej(); forward;
procedure f(var a:double); forward;
end;
var
tmp:string;
ans:char;
TheCredit:kredyt;
i,j:word;
TableD:array [1..1000] of double;
suma:^double;
function p(a:double; b:word):double;
external '.\liebe.dll';
procedure ramka(x,y:word);
external '.\liebe.dll';
function input(s:string):string;
external '.\liebe.dll';
procedure alert;
external '.\liebe.dll';
procedure kredyt.f(var a:double);
var q:real;
begin
q:=1+height/1200;
a:=value*p(q,time)*(q-1)/(p(q,time)-1);
end;
procedure kredyt.raty();
var total:double;
begin
f(total);
writeln('Wysokosc raty to: ',total:0:2);
TableD[1]:=total;
new(suma);
suma^:=0;
suma^:=TableD[1]*time;
writeln('suma: ',suma^:0:2);
writeln('koszt: ',suma^-value:0:2);
readkey;
end;
procedure kredyt.malej();
var total,may:double;
i:word;
begin
f(total);
for i:=1 to time do
TableD[i]:=total;
may:=total-value/time;
may:=may/time;
for i:=1 to time do
begin
TableD[i]:=TableD[i]+may*((time div 2) - i);
 end;
gotoxy(1,1);
for i:=1 to time do
begin
writeln(i,': ',TableD[i]:0:2);
delay(speed);
if (i mod 20 = 0) then
begin
writeln('Press any key...');
readkey;
end;
end;
new(suma);
suma^:=0;
for i:=1 to time do
suma^:=suma^+TableD[i];
for i:=1 to 20 do write('=');
writeln;
writeln('suma: ',suma^:0:2);
writeln('koszt: ',suma^-value:0:2);
readkey;
end;
function choose(s:string):char;
external '.\liebe.dll';
function to_value(tmp:string; var d:double):boolean;
var kod:word;
begin
kod:=0;
val(tmp,d,kod);
if kod<>0 then
begin
if tmp[kod]=',' then tmp[kod]:='.';
end
else
begin
to_value:=true;
exit;
end;
kod:=0;
val(tmp,d,kod);
if (kod = 0) and (d<>0) then
to_value:=true
else
to_value:=false;
end;
function to_noumber(tmp:string; var b:word):boolean;
var kod:word;
begin
kod:=0;
val(tmp,b,kod);
if kod<>0 then
begin
if tmp[kod]=',' then tmp[kod]:='.';
end
else
begin
to_noumber:=true;
exit;
 end;
kod:=0;
val(tmp,b,kod);
if (kod = 0) and (b<>0) then
to_noumber:=true
else
to_noumber:=false;
end;
function month(a:word):word;
begin
if a = 0 then month:=12 else month:=a;
end;
procedure doc();
var plik:text;
dd,mm,rr,h,m,s,ss,WTF,i,kod:word;
tmp,tmp2:string;
name:string;
data:text;
procedure linia;
var i:word;
begin
for i:=1 to 45 do write(plik,'-'); writeln(plik,''); //Linia poprzeczna
end;
begin
getdate(rr,mm,dd,WTF);
gettime(h,m,s,ss);
str(dd,tmp);
name:=tmp;
str(mm,tmp);
name:=name+'.'+tmp;
str(rr,tmp);
name:=name+'.'+tmp;
assign(data,'.\data.ini');
reset(data);
read(data,tmp);
if tmp='nodir' then mkdir('.\Dokumenty');
if tmp<>name then
begin
mkdir('.\Dokumenty\'+name);
rewrite(data);
write(data,name);
close(data);
end;
 str(h,tmp);
name:=name+'\'+tmp;
str(m,tmp);
name:=name+'.'+tmp;
str(s,tmp);
name:=name+'.'+tmp+'.txt';
assign(plik,'.\Dokumenty\'+name);
rewrite(plik);
tmp2:=input('Podaj poczatek:');
tmp:=tmp2[1]+tmp2[2];
val(tmp,dd,kod);
tmp:=tmp2[4]+tmp[5];
val(tmp,mm,kod);
tmp:=tmp2[7]+tmp[8];
val(tmp,rr,kod);
linia;
begin //TYLKO RAZEM!!
write(plik,'|',headline_text:((43+length(headline_text)) div 2));
for i:=1 to (45-((43+length(headline_text)) div 2)-2) do
write(plik,' ');
writeln(plik,'|');
end;
linia;
if TableD[2]>0 then
for i:=1 to TheCredit.time do
begin
str(i,tmp);
writeln(plik,'|',tmp+' rata:
':15,'|',TableD[i]:14:2,'|',dd:4,'-',month(mm+i mod 12):2,'-',rr:2,'|');
//Dane tabeli
end
else
for i:=1 to TheCredit.time do
begin
str(i,tmp);
writeln(plik,'|',tmp+' rata:
':15,'|',TableD[1]:14:2,'|',dd:4,'-',month(mm+i mod 12):2,'-',rr:2,'|');
end;
linia;
writeln(plik,'|','Suma:':30,'|',suma^:10:2,'|');
linia;
writeln(plik,'|','Calkowity koszt:':30,'|',suma^-
TheCredit.value:10:2,'|');
linia;
writeln(plik,'|','Wygenerowano na dzien:':30,'|',dd:4,'-',mm:2,'-',rr:2,'|');
linia;
writeln(plik,'|','Powered by Michal Wolinski':43,'|');
linia;
close(plik);
{repeat
ans:=choose('Wydrukować?');
until(ans in ['t','n']);
if ans='t' then print(plik);}
end;
begin
textcolor(text_defoult);
textbackground(back_defoult);
clrscr;
writeln('Program wylicza system splaty rat(ich wysokosc w kolejnych
miesiacach).');
REPEAT
clrscr;
writeln('Wcisnij "x" aby zakoäczy .');
writeln('Wcisnij "s" aby rozpocza .');
repeat
ans:=readkey;
until(ans in ['s','x']);
if ans='x' then exit;
gotoxy(1,1);
writeln('':40);
write('':40);
repeat
gotoxy(1,1);
write('Podaj wysokos kredytu: ');
readln(tmp);
if NOT to_value(tmp,TheCredit.value) then
begin
alert();
clrscr;
end;
until(to_value(tmp,TheCredit.value));
repeat
gotoxy(1,2);
write('Podaj czas(w miesiacach): ');
readln(tmp);
if NOT to_noumber(tmp,TheCredit.time) then
begin
alert();
clrscr;
gotoxy(1,1);
write('Podaj wysokosc kredytu: ',TheCredit.value:0:2);
end;
until(to_noumber(tmp,TheCredit.time));
repeat
gotoxy(1,3);
write('Podaj oprocentowanie: ');
readln(tmp);
if NOT to_value(tmp,TheCredit.height) then
begin
alert();
clrscr;
gotoxy(1,1);
writeln('Podaj wysokosc kredytu: ',TheCredit.value:0:2);
write('Podaj czas(w miesiacach): ',TheCredit.time);
end;
until(to_value(tmp,TheCredit.height));
repeat
ans:=choose('Czy raty sa stale?');
until(ans in ['n','x','t']);
clrscr;
if ans='t' then
TheCredit.raty
else if ans='n' then
TheCredit.malej;
delay(1000);
 ans:=choose('Czy przygotowac dokument?');
if ans='t' then doc();
dispose(suma);
UNTIL(ans='x');
end.