PEŁNY KURS TURBO PASCALA.docx

PEŁNY KURS TURBO PASCALA - część I
zupełne podstawy

Nie będę tutaj lał wody, więc od razu zacznijmy od konkretów!

Pascal jest doskonałym narzędziem do robienia programów. Polega to na tym, że najpierw piszemy kod programu, a potem, żeby go przerobić na plik wykonywalny (z końcówką EXE) musimy go skompilować. Wszystkie te czynności wykonujemy za pomocą programu TURBO PASCAL. Po włączeniu widzimy najczęściej niebieski ekran. Z polecenia FILE i SAVE, zachowujemy pliki (tak jak w windowsie). Aby uruchomić napisany przez nas kod, używamy polecenia RUN i klikamy w pierwszą zakładkę (RUN). Aby go skompilować, klikamy w COMPILE i sprawdzamy, czy widnieje tam napis DESTINATION DISK. Jeżeli tak jest, klikamy na COMPILE. Jeżeli natomiast jest napis DESTINATION MEMORY, klikamy na ten napis i zmienia nam się MEMORY na DISK. Dalej wykonujemy jak wyżej.

Tak oto poznaliście podstawowe komendy w TP. Teraz zajmijmy się samym programem.

Podczas kompilacji wielokrotnie mogą wystąpić błędy. Jeżeli macie dobrą wersję TP, to program pokaże wam jaki błąd zrobiliście i gdzie. Posiadacze starszych wersji muszą radzić sobie sami.

Jeżeli macie komputer powyżej Pentium (166 MHZ) to macie dużą szansę, że programy skompilowane na waszym Pascalu nie będą działać. Trzeba w tym celu ściągnąć sobie specjalnego patcha. Bez niego każdy program wykaże "RUN TIME ERROR"

I to by było chyba wszystko

PEŁNY KURS TURBO PASCALA - część II
polecenia BEGIN, END, WRITE, WRITELN

Główna część programu (tzw. blok główny) mieści się w dwóch wyrazach. Początek programu zaznaczamy pisząc BEGIN, koniec natomiast zaznaczamy słówkiem END. (koniecznie z kropką). Tak więc program, który nic nie robi, wygląda tak:

BEGIN
END.

Program się otwiera słówkiem BEGIN i kończy słówkiem END. Taki program jest oczywiście całkowicie bezużyteczny. W takim razie trzeba go trochę wzbogacić. Zacznijmy od polecenia WRITE. Rozkazuje ono napisanie jakiegoś tekstu. Przykład tekstu wygląda tak:

WRITE('Jakiś tekst niezbyt mądry');

Znasz już zatem polecenie WRITE. Na co należało by zwrócić uwagę? Między innymi na to, że tekst jak sami pewnie zauważyliście objęty jest w cudzysłowie (pojedyncze) i dodatkowo w nawiasy. Nawiasy zawsze będą istnieć przy poleceniu WRITE. Wszystko zostanie napisane co jest w nawiasie. W takim razie, po co jest cudzysłów? No więc, chodzi o to, że to co jest objęte w cudzysłowie zostanie na pewno wyświetlone na ekranie tak jak zostało to napisane. Dziwnie to brzmi, ale zobaczycie później. Komputer interpretuje to po prostu jako tekst i jeżeli chcemy coś zapisać, to zawsze w cudzysłów. I jeszcze jedno. Na końcu (za nawiasem) widnieje średnik. Zawsze trzeba go stosować na końcu polecenia. Inaczej program wskaże błędy. Potem się dowiesz, przy jakich poleceniach nie trzeba go stosować (między innymi przy poznanych już BEGIN i END).

OK. A teraz mała sztuczka, która pokaże wam dwa istotne fakty. Spójrzcie na poniższy program:

BEGIN
write('wyraz numer 1');
write('wyraz numer 2');
write('wyraz numer 3);
END.

Widzimy tu program, który kolejno wypisze wyrazy. Po pierwsze - spróbujcie włączyć ten program. Na pewno zastanawiacie się, czemu nic się nie pokazało. To normalne. Komputer jest tak szybki, że zdążył pokazać te wyrazy i poleceniem END zamknął program. Zatem tak naprawdę, program zadziałał prawidłowo, ale my tego nie zauważyliśmy. Aby zobaczyć, co też komputer napisał musimy jakoś przerobić w/w kod, aby program zatrzymał się tuż przed jego końcem. Do tego służy polecenie READLN. Zastosowanie tego zostawmy sobie na później. Jak na razie będziemy stosować to tylko po to, abyśmy zobaczyli to co napisaliśmy. Tzn. zatrzymali program, aż do naciśnięcia jakiegoś klawisza. Zatem nasz program będzie wyglądał tak:

BEGIN
write('wyraz numer 1');
write('wyraz numer 2');
write('wyraz numer 3');
readln;
END.

I jak? Działa? Jak nie to coś pochrzaniłeś. Program powinien wyświetlić takie coś: "wyraz numer 1wyraz numer 2"...i tak dalej Zastanawiasz się pewnie dlaczego tak beznadziejnie to wygląda. Jest tak dlatego, że samo polecenie WRITE rozkazuje komputerowi napisać coś, a potem tak to zostawić. Następny zatem napis będzie zaraz po poprzednim, bez rozkazu zejścia niżej. W takim razie, powyższy program tak samo działa jak poniższy:

BEGIN
write('wyraz numer 1wyraz numer 2wyraz numer3');
readln;
END.

Porównajcie sobie dwa powyższe programy, a zobaczycie o co chodzi.

Teraz zajmijmy się czymś bardziej skomplikowanym. Załóżmy, że chcemy, aby program obliczył proste dodawanie. Spróbujcie zrobić eksperyment i napiszcie poniższy program:

BEGIN
write('2+3');
readln;
END.

I co się pokazało? Zamiast żądanego wyniku "5" na pewno napis "2+3", czyż nie? Zadziałało się tak dlatego, gdyż napisane było to w cudzysłowie. Komputer więc nie zwrócił uwagi, że jest to polecenie matematyczne. Po prostu napisał, to co mu kazałeś. Aby komputer wyświetlił napis "5" można albo po prostu napisać write('5'); lub coś takiego: write(2+3);. Czym się to różni? Tym, że nie ma tu cudzysłowu. Teraz już możecie śmiało wyliczać skomplikowane rzeczy.

A teraz nieco z innej parafii. Jak zrobić, aby tekst schodził akapit niżej? Nic trudniejszego. Wystarczy użyć polecenia WRITELN. Używa się go tak jak polecenia WRITE. Różni się tylko tym, że schodzi na końcu o jeden wers w dół. Poprawnie napisany program i przejrzyście wyglądający ma postać taką:

BEGIN
writeln;
writeln;
writeln;
write('2+3=');
write(2+3);
readln;
END.

Polecenie WRITELN; każe po prostu zejść linię niżej bez jakiegokolwiek tekstu. Następnie komputer napisze "2+3", po czym obliczy, że 2+3 jest 5 i napisze właśnie tą liczbę. Całość wyglądać będzie następująco: "2+3=5". Czyż PASCAL nie jest wspaniały?

Kolejna sprawa to, oddzielenia. Do w/w polecenia, gdzie komputer ma wyliczyć, ile jest 2+3, nie musimy używać aż dwóch poleceń WRITE. Wystarczy jedno polecenie, a teksty te należy oddzielić przecinkiem. Zatem poniższe trzy programy, działają tak samo. Przyjrzyjcie się im:

BEGIN
write('2+3=');
write(2+3);
readln;
END.

BEGIN
write('2+3=',2+3);
readln;
END.

BEGIN
write('2+3=5');
readln;
END.

Programy te wykonują to samo chociaż ich kod jest inny. Sposobów na wykonanie tak prostego działania jest wiele. Spróbuj sam wynaleźć inny sposób. Zwróćcie uwagę na środkowy program. Został tam użyty przecinek. Można go bez problemu używać. Spójrzcie jak wygląda program bez używania przecinku i po jego użyciu:

BEGIN
write(' tekst jakiś ');
write(9-2);
write(' drugi tekst ');
write('10');
readln;
END.

Był to prosty program , który wyświetli coś takiego: "tekst jakiś 7 drugi tekst 10". Spójrzcie na powyższy program i porównajcie go z programem poniżej:

BEGIN
write(' tekst jakiś ',9-2,' drugi tekst 10');
readln;
END.

Czyż nie jest prościej? Na tym właśnie polega stosowanie przecinka. I to byłby koniec tej lekcji. Zapraszam do następnej części.

PEŁNY KURS TURBO PASCALA - część III
polecenia READ, READLN, podstawy zmiennych

Na poprzedniej lekcji dowiedziałeś się, że program mieści się w znacznikach BEGIN i END. Dowiedziałeś się również, że TP można zmusić, aby coś napisał. Na tej lekcji postaramy się go zmusić, aby coś odczytał. Załóżmy, że chcemy, aby komputer wprowadził do pamięci jakieś imię. Chcemy zrobić program, który zapyta jak mamy na imię, po czym wyświetli nam napis: „Cześć (i tu imię). Miłego dnia!!!. Umiesz już napisać taki tekst, ale jak zrobić, żeby komputer wstawił do tekstu imię. Ponadto najpierw trzeba o to imię zapytać, a dopiero potem wstawić. Do tego służą tzw. zmienne. Zmienne możemy oznaczać dowolną literą lub wyrazem. Załóżmy, że zmienną, która będzie reprezentować imię użytkownika, nazwiemy po prostu „imie” (bez polskich liter). W TURBO PASCALU każdą zmienną musimy najpierw zdeklarować zanim jej użyjemy. Zmienne deklarujemy poleceniem „VAR” i robimy to jeszcze przed programem (przed poleceniem BEGIN). Po słowie „VAR” wypisujemy wszystkie zmienne. W naszym programie będzie tylko jedna zmienna o nazwie „imie”. Po jej napisaniu trzeba jeszcze przypisać jej typ. Na razie poznasz tylko podstawowe typy zmiennych. Jak każdy wie, imię człowieka składa się z liter, więc jest to zwykły ciąg liter. Zmienna nasza będzie zatem typu STRING. Zapamiętajcie tę nazwę. Program, który zadeklaruje zmienną będzie więc wyglądał tak:

VAR
imie:string;

BEGIN

END.

Mamy więc program, który deklaruje zmienną typu STRING (czyli ciąg znaków). Teraz (w głównym bloku programu między BEGIN i END) musimy coś napisać, aby komputer spytał użytkownika jak ma na imię. Nic prostszego:

VAR
imie:string;

BEGIN
write('Jak masz na imię?');
END.

Już jesteśmy o krok dalej. Teraz musimy jakoś zatrzymać program, aby gość siedzący przed komputerem mógł napisać jak ma na imię i nacisnąć ENTER. Nic prostego. Do tego służy polecenie READ. Więc wstawmy to polecenia do naszego programu:

VAR
imie:string;

BEGIN
write('Jak masz na imię?');
read(imie);
END.

Zwróćcie uwagę na konstrukcję READ. W nawiasie podajemy zmienną, do której ma być zapisana wartość z klawiatury. To znaczy, że to, co użytkownik napisze będzie liczone jako zmienna „imie”. Do polecenia w nawiasie nie stosujemy cudzysłowu i pamiętamy, żeby na końcu postawić średnik. Kolejnym krokiem będzie wykombinowanie, aby program napisał ładne powitanie z imieniem. Robimy to następująco:

VAR
imie:string;

BEGIN
write('Jak masz na imię?');
read(imie);
write('Witaj ');
write(imie);
write('. Życzę miłego dnia!!!');
readln;
END.

No to po kolei. Jak już zauważyłeś aby wyświetlić zmienną wystarczy użyć zwykłego polecenia WRITE podając w nawiasie nazwę zmiennej (bez cudzysłowu). Zwróć uwagę na linię „write('. Życzę miłego dnia!!!'); Kropka przed zdaniem jest po to, aby zdanie zakończyło się po imieniu. Jest to zabieg stylistyczny i nie służy do niczego specjalnego. Wszystko razem po włączeniu powinno wyglądać tak: „Witaj Zenek. Życzę miłego dnia!!!”. Już wiesz po co ta kropka? Użytkownik nie wprowadzi jej przecież, a komputer nie zna naszego języka. Spróbuj bez kropki, a zobaczysz, co to znaczy estetyka programu. Ale jest to na szczęście niezbyt duży problem. A teraz jeszcze przeróbmy nasz kod programu, aby wyglądał on ładniej i miej miejsca zajmował. Tak, więc dobry kod programu wyglądałby tak:

VAR
imie:string;

BEGIN
writeln;
writeln('Jak masz na imię?');
writeln;
read(imie);
write('Witaj ',imie,'. Życzę miłego dnia!!!');
readln;
END.

W powyższym programie dodatkowo zostało dopisane zamiast WRITE, polecenie WRITELN, gdyż trzeba zauważyć, że nawet pytanie „Jak masz na imię?” musi ładnie wyglądać. Oprócz tego polecenia WRITELN; działają jak separator i nie pozwalają wszystkiego wyświetlić w jednej linii. Pokombinujcie z tymi poleceniami a zobaczycie, na czym to polega.

Teraz spróbujmy wzbogacić nasz program. Załóżmy, że użytkownik wpisze jako swoje imię jakieś bzdety (na przykład 150 liter). Program zadziała, ale pomyślcie jak będzie to wyglądać. Trzeba, więc dać ograniczenie, aby użytkownik nie mógł wprowadzić zbyt wielu liter. Nie jest to specjalnie trudne. Wystarczy do typu zmiennej przypisać coś takiego:

VAR
imie:string[10];

BEGIN
writeln;
writeln('Jak masz na imię?');
writeln;
read(imie);
write('Witaj ',imie,'. Życzę miłego dnia!!!');
readln;
END.

Jak się pewnie już domyśliłeś, zmienna ta będzie ograniczona do dziesięciu liter. Użytkownik będzie mógł wprowadzić więcej liter, ale wyświetlone zostanie tylko dziesięć.

A teraz zajmijmy się liczbami. Zbudujmy prosty kalkulator, który będzie dodawał do siebie dwie liczby. Program najpierw spyta, jakie mają to być liczby, a potem je doda. Sama zasada jest podobna jak w przykładach powyżej, z tym, że zmienna będzie innego typu. Poza tym będziemy potrzebować nie jednej a dwóch zmiennych. Użytkownik przecież ma wprowadzić dwie liczby. Istnieją różne typy zmiennych oznaczające liczby. Dla początkujących użyjemy zmiennej typu LONGINT. Nie będę tłumaczył na czym ona polega, ale powiem, że mieści w sobie liczby od kilku miliardów albo nawet i więcej do minus kilku miliardów albo i nawet mniej :))) Powinna więc zadowolić każdego. Dodam jeszcze, że zapamiętuje tylko liczby całkowite, więc ułamki zostawmy sobie, na kiedy indziej. Zatem zacznijmy robić program. Poniżej znajduje się kod, który bez problemu powinieneś rozumieć:

VAR
liczba1:longint;
liczba2:longint;

BEGIN
writeln;
writeln('Podaj pierwszą liczbę');
read(liczba1);
writeln('Podaj drugą liczbę');
read(liczba2);
write('Ich suma wynosi: ',liczba1+liczba2);
readln;
END.

Zrozumiałe? Jeżeli nie to nie wiem coś ty za jeden. Oczywiście liczby można nie tylko dodawać, ale i dzielić, odejmować, mnożyć, podnosić do kwadratu itp. ale o tym w innej części kursu. Zaraz pod słówkiem „VAR” widzimy dwie zmienne: liczba1 i liczba2. Oba są typu LONGINT, czyli tego samego typu. Po co więc pisać dwa razy tą samą rzecz. Poprawiony program będzie więc wyglądał tak:

VAR
liczba1,liczba2:longint;

BEGIN
writeln;
writeln('Podaj pierwszą liczbę');
read(liczba1);
writeln('Podaj drugą liczbę');
read(liczba2);
write('Ich suma wynosi: ',liczba1+liczba2);
readln;
END.

Widzicie jakie to proste? Zatem zmienne tego samego typu można w ten właśnie sposób oddzielić przecinkami (bez spacji). Niby to nic takiego, ale wyobraźcie sobie, że mamy 50 takich zmiennych. Zamiast do wszystkich dopisywać typ, wystarczy wypisać je po przecinku.

Teraz poznamy jeszcze jedną sztuczkę. Załóżmy, że chcemy, aby jakaś zmienna miała już jakąś wartość. Na przykład do powyższego programu. Niech użytkownik nie wprowadza żadnej liczby, a program ma już zapisane w sobie ich wartości. Do tego służy instrukcja przypisania. Stosuje ją się bardzo prosto. Np. liczba1:=71; W ten sposób przypisaliśmy liczbę 71 do zmiennej „liczba1”. Zwróćcie uwagę na znak przypisania. Jest to dwukropek i znak równości. Po tym wszystkim znajduje się oczywiście średnik. Zatem poniższy program nie zrobi nic innego, jak napisze liczbę 10:

VAR
liczba1,liczba2:longint;

BEGIN
liczba1:=2;
liczba2:=8;
write(liczba1+liczba2);
readln;
END.

Mam nadzieję, że wszyscy rozumieją, o co chodzi! Teraz nieco skomplikuję sprawę. Załóżmy, że chcemy, aby jedna zmienna była zależna od drugiej. Zróbmy pogram, który pyta użytkownika o jakąś liczbę i wyświetla ją pomnożoną przez 2. Można to zrobić w różny sposób. Spójrzcie na poniższy program. Jest to jeden ze sposobów.

VAR
liczba:longint;

BEGIN
writeln;
writeln('Podaj jakąś liczbę');
read(liczba);
write('Liczba ta pomnożona przez 2 wynosi ',liczba*2);
readln;
END.

Był to prosty sposób na pokazanie mnożenia (dokonujemy gwiazdką jakby co). Użytkownik wprowadził jakąś liczbę, a program ją wyświetlił, ale pomnożoną przez 2. A teraz spójrzcie na poniższy przykład. Działa on tak samo jak poprzedni, z tym, że jest inaczej zbudowany:

VAR
liczba,iloczyn:longint;

BEGIN
writeln;
writeln('Podaj jakąś liczbę');
read(liczba);
iloczyn:=liczba*2;
write('Liczba ta pomnożona przez 2 wynosi ',iloczyn);
readln;
END.

Był to nic innego jak przykład, że instrukcje przypisania można stosować nie tylko do liczb, ale i innych zmiennych, co daje nam już bardzo duże możliwości. Można przecież wykonać takie instrukcje przypisania jak: „liczba:=iloczyn*(iloczyn-1)-24” itp. O tym wszystkim dowiecie się później. Na razie najważniejsze jest, że wiecie, co to jest instrukcja przypisania i jak z niej korzystać. Teraz została jeszcze jedna sprawa. Jak przypisać do zmiennej typu STRING zwykły tekst. Nie jest to trudne. Wystarczy zastosować instrukcję przypisania, a samą wartość podać w cudzysłowie. Np: imie:=’Franek’;

Na koniec do omówienia zostało jeszcze polecenie READLN. Oprócz tego, że używamy READLN jak dotąd do przerywania programu, służy innym celom. Cele te jednak wykraczają jak na razie w wasz zakres wiedzy, więc może innym razem. Zapraszam więc do następnej części kursu.

PEŁNY KURS TURBO PASCALA - część IV
podstawowe polecenia modułu CRT

Wypadałoby tu zacząć od wyjaśnienia słowa „moduł”. Otóż w Pascalu jest pełno poleceń, a wszystkie one nie są zasługą samego Pascala. Czasami do Pascala trzeba dorzucić jakiś moduł, aby one zadziałamy. Moduł CRT jest już w Pascalu wbudowany. Jest często stosowany w najróżniejszych programach i myślę, że ma użyteczne funkcję. Wszystkie moduły (nie tylko CRT) trzeba najpierw zdeklarować zanim się ich użyje, (czyli zanim użyje się ich poleceń). Zmienne deklarowaliśmy poleceniem „VAR”, natomiast moduły deklarować będziemy za pomocą słówka „USES”. Wpisujemy to jeszcze przed „VAR” na samym początku programu. Sam moduł tak właściwie niczym nie jest – daje tylko możliwość stosowania kilku nowych poleceń. Właśnie te kilka poleceń poznasz na tej lekcji. Zat...