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. Zatem, najprostszy program, który ma moduł CRT, wygląda tak:

USES CRT;

BEGIN

END.

W ten właśnie sposób deklarujemy moduł CRT. Zwróć uwagę, że po słówku „USES” nie ma żadnego znaku. Na końcu linii pamiętamy oczywiście o średniku. Tak zdeklarowany moduł możemy wykorzystać. Najważniejsze z jego poleceń to:

CLRSCR;

To skomplikowane polecenie jest dość użyteczne. Po prostu czyści ekran z jakiegokolwiek tekstu. Każdy tekst znajdujący się po tym poleceniu będzie wyświetlany na czystym ekranie (żadnych innych rzeczy tam nie będzie jak dotychczas). Spróbuj napisać następujące programy i zobacz sam różnice:

USES CRT;

BEGIN

write('Jakiś tekst');

readln;

END.

USES CRT;

BEGIN

clrscr;

write('Jakiś tekst');

readln;

END.

Najpierw spróbuj włączyć pierwszy program, a potem drugi. Widzisz różnice?

DELAY(x);

Polecenie to daje możliwość wstrzymania programu na określoną ilość czasu (przydaje się zwłaszcza w programach demonstracyjnych). Za „x” wstawiamy czas, na jaki program ma być wstrzymany (1000 to jedna sekunda). Przykład programu z zastosowaniem polecenia DELAY znajduje się poniżej:

USES CRT;

BEGIN

write('Jakiś tekst numer 1');

delay(3500);

write('Jakiś tekst numer 2');

readln;

END.

Powyższy program napisze pierwsze zdanie i po upływie trzech i pół sekundy - drugie zdanie. Nie jest to chyba zbyt skomplikowane.

SOUND(x);

Przyszedł najwyższy czas, aby zademonstrować dźwięk. Nie będzie to dźwięk wydawany z głośników, a z tegoż urządzona, co się znajduje w środku komputera. Za „x” wstawiamy tzw. częstotliwość, tak samo jak w przypadku „DELAY”. Samo polecenie „SOUND” nam nic nie da, gdyż komputer szybko odegra ten dźwięk i pojedzie dalej. Zaraz po poleceniu „SOUND” najlepiej stosować polecenie „DELAY”, które zatrzyma dźwięk na określoną ilość czasu. W ten sposób możemy już grać proste melodyjki. Z osobistych doświadczeń wiem, że niektórzy nie wytrzymują dźwięku o częstotliwości 2200. Radzę popróbować. Ale najpierw przeczytajcie jeszcze poniższe polecenie.

NOSOUND;

Służy do przerywania jakiegokolwiek dźwięku wydobywającego się ze spikera. Na końcu programu radzę to stosować, bo może okazać się, że dźwięk nie ustanie. W celu przećwiczenia tych funkcji radzę napisać następujący program:

USES CRT;

BEGIN

sound(2200);

delay(5000);

nosound;

END.

Program ten przez pięć sekund da nam bardzo denerwujący dźwięk.

GOTOxy(współrzędne);

Załóżmy, że chcemy aby nasz tekst zaczynał się mniej więcej w środku ekranu. Stosowanie pięćdziesiąt razy polecenia „WRITELN;” a potem odmierzenie ilości spacji byłoby nieco niewygodne. Dlatego właśnie powstało polecenie „GOTOxy”. Polecenie to rozkazuje przejście kursora do danej pozycji. Aby wszystko ładnie wyglądało, warto by było przedtem użyć „CLRSCR”. Po poleceniu „GOTOxy” podajemy w nawiasach współrzędne. Pierwsza współrzędna jest odległością w poziomie (ilość kratek od lewej strony ekranu), druga zaś jest odległością w pionie (ilość kratek od górnej części ekranu). Możemy, więc napisać poniższy program.

USES CRT;

BEGIN

clrscr;

gotoxy(30,15);

write('Jakiś tekst');

readln;

END.

Powyższy tekst zaczynać się będzie w trzydziestej kolumnie i piętnastym wierszu. A teraz spróbujcie użyć ten sam program, ale bez polecenia „CLRSCR”, a zobaczycie jak beznadziejnie będzie on wyglądał.

HALT;

W zasadzie, to polecenie „HALT” nie jest w składzie modułu CRT, i działa również bez niego, jednak chciałem go teraz opisać. Nie będzie to zbyt zawiłe, gdyż polecenie to robi nic innego, jak wychodzi z programu. Jak tylko program napotka to polecenie na swojej drodze, od razu przerywa program i natychmiast z niego wychodzi. Nie muszę chyba więcej wyjaśniać.

Jest oczywiście jeszcze wiele innych poleceń ze składni modułu CRT, ale staram się, aby wszystkie te polecenia były przyswajane powoli. Na razie powinieneś poćwiczyć z tym, co już umiesz. Dam ci małe zadanie domowe. Zrób program, który napisze najpierw kilka zdań, potem obliczy iloczyn dowolnych dwóch liczb wprowadzanych przez użytkownika, a na końcu wyświetli na środku ekranu napis „DOWIDZENIA!!!” przez pięć sekund. Niezłe zadanko, co? Ty już to umiesz!!!

PEŁNY KURS TURBO PASCALA - część V

instrukcja warunkowa IF..THEN..ELSE oraz operatory

Mam nadzieję, że ukończyłeś już lekturę wszystkich poprzednich części kursu zanim zabrałeś się za bieżący. Wkraczamy, bowiem w coraz to bardziej trudne progi i niestety twoja koncentracja będzie musiała się bardziej wysilić. Ale dosyć już tego klepania, czas zaczynać. Załóżmy, że chcemy stworzyć program, który będzie pytał użytkownika o jakąś liczbę. Jest to oczywiście dla ciebie bułka z masłem, ale spróbujmy ten program rozbudować. Program ma pokazywać, czy liczba, którą wprowadził użytkownik jest większa od stu, mniejsza lub równa. Załóżmy, że użytkownik wprowadza liczbę 230. Program ma napisać, że liczba jest większa od stu. Jak użytkownik wprowadzi np. liczbę 17, to program ma napisać, że liczba jest mniejsza od stu. No i wreszcie, jak użytkownik wprowadzi 100, program napisze, że liczba, którą wprowadził użytkownik jest równa 100. Do tych zadań użyjemy jeszcze ci nieznanej instrukcji warunkowej. Zanim jednak się nią zajmiemy, napiszmy część programu, który może wyglądać tak:

USES CRT;

VAR

liczba:longint;

BEGIN

clrscr;

writeln('Wprowadź jakąś liczbę');

read(liczba);

END.

Powyższy program nie powinien was dziwić - powinniście już go rozumieć. Teraz trzeba coś zrobić, aby program wykonał jedną z trzech opcji. Ma napisać, że liczba jest większa od stu albo mniejsza od stu albo równa. No to zaczynajmy. Zajmijmy się najpierw przypadkiem, gdzie liczba jest równa 100. Program będzie więc wyglądał tak:

USES CRT;

VAR

liczba:longint;

BEGIN

clrscr;

writeln('Wprowadź jakąś liczbę');

read(liczba);

IF liczba=100 THEN writeln('Podałeś liczbę równą 100');

readln;

END.

A teraz wyjaśnienie. Po słowie „IF” znajduje się zawsze warunek. W tym wypadku warunkiem jest przyrównanie liczby do stu. Jeżeli liczba jest równa 100, to program wykonuje to, co znajduje się po słowie „THEN”. Jeżeli program stwierdzi, że nie jest to liczba 100, omija ten warunek całkowicie go ignorując. Rozumiecie? Teraz trzeba jeszcze przewidzieć dwa inne przypadki. Ktoś przecież może napisać liczbę mniejszą do sto albo większą. Cały program będzie więc wyglądał tak:

USES CRT;

VAR

liczba:longint;

BEGIN

clrscr;

writeln('Wprowadź jakąś liczbę');

read(liczba);

IF liczba=100 THEN writeln('Podałeś liczbę równą 100');

IF liczba>100 THEN writeln('Podałeś liczbę większą od 100');

IF liczba<100 THEN writeln('Podałeś liczbę mniejszą od 100');

readln;

END.

W ten prosty sposób rozważyliśmy wszystkie możliwe przypadki. Logiczne jest że zawsze wystąpi jeden z tych trzech przypadków (bo każda liczba jest albo równa 100 albo mniejsza albo większa - innej możliwości nie ma). Logiczne także jest, że nie mogą się włączyć np. dwa warunki na raz. Przecież nie istnieje taka liczba, co by np. była jednocześnie większa od stu i mniejsza. Mam nadzieję, że to rozumiecie. Jak dotąd poznaliście trzy podstawowe operatory (równe, większe i mniejsze). Wszystkie podstawowe zebrane są poniżej:

= równe

> większe niż

< mniejsze niż

>= większe lub równe

<= mniejsze lub równe

<> różne

I wszystko jasne. A teraz kolej na następny „kwiatek” w TURBO PASCALU. Załóżmy, że chcemy zrobić instrukcję warunkową, co by sprawdzała, czy liczba, którą podał użytkownik równa jest 1000. Inne przypadki nas nie interesują, i gdy liczba nie jest równa tysiąc, następuje koniec programu. Można to zrobić metodą znaną, czyli tak:

USES CRT;

VAR

liczba:longint;

BEGIN

clrscr;

writeln('Wprowadź jakąś liczbę');

read(liczba);

IF liczba=1000 THEN writeln('Brawo! Podałeś liczbę tysiąc!');

IF liczba>1000 THEN halt;

IF liczba<1000 THEN halt;

readln;

END.

Widzimy bardzo prosty program, który zaraz się kończy, gdy liczba, którą wprowadził użytkownik nie jest równa 1000. Są tam zastosowane dwie dodatkowe instrukcje,(gdy jest większa od 1000 lub mniejsza). Można to zrobić jeszcze inaczej:

USES CRT;

VAR

liczba:longint;

BEGIN

clrscr;

writeln('Wprowadź jakąś liczbę');

read(liczba);

IF liczba=1000 THEN writeln('Brawo! Podałeś liczbę tysiąc!');

IF liczba<>1000 THEN halt;

readln;

END.

Teraz program sprawdza, czy liczba jest różna od tysiąc a nie czy jest większa czy mniejsza. W sumie na jedno wychodzi, ale kod programu mniej zajmuje. Teraz poznasz trzeci sposób na wykonanie takiego programu. Służy do tego polecenie, „ELSE”, który patrzy, czy użytkownik wprowadził inną liczbą niż przewidzianą. Spójrzcie na poniższy program:

USES CRT;

VAR

liczba:longint;

BEGIN

clrscr;

writeln('Wprowadź jakąś liczbę');

read(liczba);

IF liczba=1000 THEN writeln('Brawo! Podałeś liczbę tysiąc!')

ELSE halt;

readln;

END.

Polecenie ELSE zadziała, jeżeli użytkownik wprowadził liczbę, która nie była przewidziana przez wcześniejsze polecenie lub polecenia „IF”. Zwróćcie uwagę na bardzo ważny szczegół. PRZED POLECENIEM ELSE NIE MA ŚREDNIKA. Jest to bardzo ważne i nawet dobrzy programiści o tym czasami zapominają. Zastosowanie „ELSE” lepiej ukazuje ten program:

USES CRT;

VAR

liczba:longint;

BEGIN

clrscr;

writeln('Wprowadź jakąś liczbę od 1 do 5');

read(liczba);

IF liczba=1 THEN writeln('Brawo! Podałeś liczbę 1');

IF liczba=2 THEN writeln('Brawo! Podałeś liczbę 2');

IF liczba=3 THEN writeln('Brawo! Podałeś liczbę 3')

ELSE writeln('Na pewno nie podałeś liczby 1, 2 lub 3');

readln;

END.

Przypominam jeszcze raz na brak średnika przed „ELSE” co doskonale ukazuje powyższy program. Teraz, gdy już znasz instrukcję warunkową, można przejść do bardziej skomplikowanych poleceń. Załóżmy, że program ma pytać użytkownika o dwie liczby. Najpierw program każe podać pierwszą liczbę. Potem program każe podać liczbę, która podzielona przez dwa daje liczbę pierwszą (czyli pierwsza liczba pomnożona przez dwa daje liczbę drugą). Będzie to takie zadanie dla użytkownika. Do tego musimy zastosować trochę bardziej skomplikowane obliczenia. Może tym razem od razu pokaże wam jak będzie wyglądał cały program (wierze w waszą inteligencję).

USES CRT;

VAR

liczba1,liczba2:longint;

BEGIN

clrscr;

writeln('Wprowadź jakąś liczbę');

read(liczba1);

writeln('A teraz podaj ile to jest: pierwsza liczba pomnożona przez dwa?');

read(liczba2);

IF liczba1*2=liczba2 THEN writeln('Brawo! Umiesz mnożyć!!!');

IF liczba1*2<>liczba2 THEN writeln('Co ty? Mnożyć nie umiesz?');

readln;

END.

W programie tym zastosowaliśmy trochę matematyki. Program sprawdza, czy pierwsza liczba pomnożona przez dwa równa się liczbie drugiej. Jeżeli tak to program wypisuje odpowiedni tekst. Jeżeli nie to ochrzania użytkownika o nieumiejętność mnożenia. Niezłe co nie?

Przyszła kolej na następną ważną rzecz. Jak pewnie zauważyłeś, wszystkie poprzednie programy z instrukcją warunkową wykorzystywały tylko jedno polecenie po słówku „THEN”. A co jeśli trzeba wykonać kilka rzeczy, jeżeli dany warunek zostanie spełniony. Niech na przykład użytkownik wprowadzi jakąś liczbę. Program ma się wyłączyć, jeżeli ta liczba jest większa od 50. Jeżeli liczba jest mniejsza, to program ma napisać coś i zagrać melodię. Widzimy, że program wykonać ma dwa polecenie. Nie można tego zrobić tak:

USES CRT;

VAR

liczba:longint;

BEGIN

clrscr;

writeln('Wprowadź jakąś liczbę');

read(liczba);

IF liczba>50 THEN halt;

IF liczba<=50 THEN writeln('Brawo! Liczba jest mniejsza lub równa 50');

sound(2200);

delay(3000);

readln;

END.

Jeżeli program ma grać, gdy liczba jest mniejsza lub równa 50, to powyższy program jest BŁĘDNY. Program nie wie, czy polecenie „SOUND” i następne należą do instrukcji warunkowej, czy są po prostu dalej. Prawidłowy program wyglądać będzie tak:

USES CRT;

VAR

liczba:longint;

BEGIN

clrscr;

writeln('Wprowadź jakąś liczbę');

read(liczba);

IF liczba>50 THEN halt;

IF liczba<=50 THEN

BEGIN

writeln('Brawo! Liczba jest mniejsza lub równa 50');

sound(2200);

delay(3000);

END;

readln;

END.

W w/w programie, polecenia, które mają być wykonane gdy warunek zostanie spełniony są objęte w dodatkowe bloki, czyli między słówka „BEGIN” i „END;” (koniecznie END ze średnikiem). Przy bardziej skomplikowanych poleceniach trzeba uważać by się nie pogubić w tych wszystkich słówkach. Trzeba pamiętać, że każde „BEGIN” trzeba zamknąć „END”. Zatem ilość słówek „BEGIN” jest równa ilości słówek „END”. Widzicie, jakie to proste. Żeby jeszcze wam ułatwić sprawę, pokaże wam coś takiego jak wcięcia. Nie są to żadne polecenia, a sposób pisania programu, aby się w nim nie pogubić. Porównajcie powyższy program z poniższym.

USES CRT;

VAR

liczba:longint;

BEGIN

clrscr;

writeln('Wprowadź jakąś liczbę');

read(liczba);

IF liczba>50 THEN halt;

IF liczba<=50 THEN

BEGIN

writeln('Brawo! Liczba jest mniejsza lub równa 50');

sound(2200);

delay(3000);

END;

readln;

END.

Osobiście radzę stosować wcięcia, gdyż nie macie nawet pojęcia jak może to ułatwić tworzenie programu.

Kiedy już przebrnęliśmy przez podstawowe wieści, czas wreszcie zająć się „prawdziwymi” operatorami. Służą one do grupowania warunków. Załóżmy, że użytkownik ma wprowadzić liczbę od 1 do 10. Program ma pokazać, czy liczba, którą wprowadził użytkownik jest parzysta czy nie. Parzyste liczby z tego przedziału to 2, 4, 6, 8 i 10. Nieparzyste to: 1, 3, 5, 7, 9. Gdybyśmy liczyli na piechotę, program wyglądałby tak:

USES CRT;

VAR

liczba:longint

BEGIN

clrscr;

writeln('Wprowadź jakąś liczbę od 1 do 10');

read(liczba);

IF liczba=2 THEN writeln('Wprowdziłeś liczbę pażystą');

IF liczba=4 THEN writeln('Wprowdziłeś liczbę pażystą');

IF liczba=6 THEN writeln('Wprowdziłeś liczbę pażystą');

IF liczba=8 THEN writeln('Wprowdziłeś liczbę pażystą');

IF liczba=10 THEN writeln('Wprowdziłeś liczbę pażystą');

IF liczba=1 THEN writeln('Wprowdziłeś liczbę niepażystą');

IF liczba=3 THEN writeln('Wprowdziłeś liczbę niepażystą');

IF liczba=5 THEN writeln('Wprowdziłeś liczbę niepażystą');

IF liczba=7 THEN writeln('Wprowdziłeś liczbę niepażystą');

IF liczba=9 THEN writeln('Wprowdziłeś liczbę niepażystą');

readln;

END.

Trochę kosmicznie to wygląda, ale jest zrozumiałe. Program można by skrócić za pomocą operatorów. Pierwszym, jaki poznasz jest operator „OR” (alternatywa). Odpowiada polskiemu wyrazowi „lub”. Doskonale nadaje się do tego programu. Spójrz na poniższy kod:

USES CRT;

VAR

liczba:longint

BEGIN

clrscr;

writeln('Wprowadź jakąś liczbę od 1 do 10');

read(liczba);

IF (liczba=2) OR (liczba=4) OR (liczba=6) OR (liczba=8) OR (liczba=10) THEN writeln('Wprowdziłeś liczbę pażystą');

IF (liczba=1) OR (liczba=3) OR (liczba=5) OR (liczba=7) OR (liczba=9) THEN writeln('Wprowdziłeś liczbę niepażystą');

readln;

END.

Program poprzedni miał taką formę:, „jeżeli liczba=2 to…, jeżeli liczba=4 to…, jeżeli liczba=6 to… i tak dalej. Takiej formy się nie stosuje (jest poprawna, ale niewygodna). Program z operatorem ma taką postać:, „jeżeli liczba=2 lub liczba=4 lub liczb=6 lub liczba=8 lub liczba=10 to… Chyba każdy widzi, że stosowanie operatorów jest łatwe. Pamiętać trzeba jeszcze, że jeżeli stosujemy jakikolwiek operator, to warunki muszą być w NAWIASACH. Doskonale to widać na powyższym programie. To był operator alternatywy („OR”). Teraz czas poznać operator koniunkcji („AND”). W powyższym programie napis się wyświetlał, gdy co najmniej jeden z warunków został spełniony. Gdybyśmy zastosowali tam „AND”, każdy warunek musiałby być spełniony. Odpowiada to polskiemu wyrazowi „i”. Wszystko się zaraz wyjaśni na podstawie programu. Załóżmy, że chcemy zrobić program, który sprawdza, czy liczba, którą wprowadził użytkownik jest między 5 a 10. Jeżeli tak, to ukaże się napis. Jeżeli nie - program się wyłączy. Zatem:

USES CRT;

VAR

liczba:longint

BEGIN

clrscr;

writeln('Wprowadź jakąś liczbę');

read(liczba);

IF (liczba>5) AND (liczba<10) THEN writeln('Liczba ta jest w przedziale od 5 do 10');

IF (liczba>=10) OR (liczba<=5) THEN halt;

readln;

END.

Program ten wyłączy się, gdy liczba będzie większa lub równa 10 lub mniejsza/równa 5. Jeżeli jest mniejsza od dziesięciu i jednocześnie większa od 5, napis się ukaże. Poznałeś, zatem już 2 operatory (były one najważniejsze).

Zajmijmy się teraz operatorem „NOT”. Jest to logiczne zaprzeczenie, czyli negacja. Nie jest on zbyt szeroko stosowany w programach, mimo to warto zwrócić na niego uwagę. Operator „NOT” po prostu neguje warunek. Pokaże wam to na przykładzie.

IF liczba<>10 THEN writeln('Liczba ta na pewno nie jest równa 10');

Powyższy program bada, czy liczba jest różna od 10. Jeżeli tak, to napis się ukaże. To samo można zrobic za pomocą operatora "NOT" w następujący sposób:

IF NOT liczba=10 THEN writeln('Liczba ta na pewno nie jest równa 10');

Czyli jeżeli liczba NIE równa się 10, to… itd. Mam nadzieję, że jest to zrozumiałe. Do opisania został jeszcze jeden operator, tzw. XOR, czyli alternatywa wykluczająca. Nie musicie się go uczyć, gdyż bardzo rzadko się go stosuje, ale jeśli ktoś czuje się na siłach, zaczynajmy. Operator XOR odpowiada wyrazowi „albo” (nie mylić z „lub”). Cała instrukcja zostaje spełniona, gdy jedno z dwóch warunków jest spełnione. Natomiast, gdy oba warunki są spełnione lub niespełnione - instrukcja się nie wykonuje (albo to albo to). To był właśnie operator XOR. Omówimy go jeszcze za moment. Teraz pokaże wam, jak można „sortować” operatory, tzn. nadawać im priorytety. Wystarczy użyć zwykłych nawiasów. Jeżeli chcemy wszystko objąć w jeszcze jeden nawias, śmiało go dajemy (zwykły, a nie żaden kwadratowy - taki, w jaki objęty jest ten tekst). Przykład zastosowania nawiasów znajduje się poniżej:

IF ((liczba1=10) AND (liczba2=20)) OR ((liczba1=5) AND (liczba2=15)) THEN "coś tam"...

W powyższym fragmencie instrukcja po słowie “THEN” zostanie spełnione w dwóch przypadkach.

Gdy liczba1=10 i liczba2=20

Gdy liczba1=5 i liczba2=15

Rozumiecie? Jak tak to dobrze.

To teraz jeszcze pokaże wam, jak działa XOR. Oba poniższe warunki znaczą to samo (tego rozumieć nie musicie, ale dobrze by było gdybyście chociaż zerknęli).

IF liczba1=10 XOR liczba2=20 THEN "coś tam"...

IF ((liczba1=10) AND (liczba2<>20)) OR ((liczba1<>10) AND (liczba2=20)) THEN "coś tam"...

To był właśnie przykład na “XOR” (wcale nie musieliście tego zrozumieć).

Dla podsumowania, przypomnijmy sobie wszystkie operatory.

OR - alternatywa - instrukcja się wykona, gdy co najmniej jeden z warunków jest spełniony ("lub").

AND - koniukcja - instrukcja się wykona, gdy wszystkie warunki są spełnione ("i").

NOT - negacja - zaprzeczenie warunku ("nie").

XOR - alternatywa wykluczająca - instrukcja się wykona tylko wtedy, gdy jeden z dwóch warunków jest spełniony ("albo").

W ten prosty sposób skończyliśmy piątą lekcję. Zapraszam do części szóstej.

PEŁNY KURS TURBO PASCALA - część VII

pętle REPEAT..UNTIL oraz WHILE..DO

Nareszcie doszliśmy do tzw. pętli. Pętle są tak częste w programach, że nie sposób bez nich żyć. Jest ich kilka rodzajów. W tej części poznacie dwa z nich, bardzo zresztą podobne do siebie. Może zacznijmy od definicji, czym jest pętla w programie. Otóż przydaje się, gdy chcemy jakąś czynność (polecenie) wykonać określoną ilość razy. Nie będziemy oczywiście stosować metody „kopiuj / wklej” i tak np. 50 razy, gdyż jest to nieładne i czasochłonne i w ogóle tak się nie robi. Do tego są właśnie pętle. Zapętlają określony fragment kodu programu i rozkazują go wykonywać dopóki jakiś warunek zostanie spełniony. Pierwszy rodzaj pętli składa się z dwóch słów: „REPEAT” (powtarzaj) oraz „UNTIL” (dopóki). Zaraz powinno wam się wszystko w głowach rozjaśnić.

Załóżmy, że chcemy, aby program napisał coś takiego: „Witam cię po raz 1, witam cię po raz 2, witam cię po raz 3, witam cię po raz 4 … i tak dalej, aż do załóżmy 100. Nie będziemy przecież pisać 100 razy tej samej kwestii metodą kopiuj/wklej. Do tego użyjemy pętli. Wprowadźmy najpierw samą pętle, a potem wyjaśnijmy.

USES CRT;

BEGIN

clrscr;

REPEAT

(tu będą polecenia)

UNTIL (warunek)

readln;

END.

Wszystko, co będzie między znacznikami „REPEAT” i „UNTIL” będzie się w kółko powtarzało, aż warunek będzie spełniony. My chcemy, aby program wypisał 100 razy ten sam tekst z ciągle zwiększającą się liczbą o jeden. Zatem do dzieła:

USES CRT;

VAR

licznik:longint;

BEGIN

clrscr;

licznik:=0;

REPEAT

licznik:=licznik+1;

writeln('Witam cię po raz ',licznik);

UNTIL licznik=100

readln;

END.

A teraz wyjaśnienie. Na początku zdeklarowaliśmy zmienną o nazwie „licznik”. Zaraz po „BEGIN” czyścimy ładnie ekran i zerujemy licznik (przypisujemy wartość 0). Zaczynamy pętle. Od tego momentu, zatem, wszystko będzie powtarzane. Licznik przyjmuje wartość „licznik+1”. Licznik miał wartość 0, zatem 0+1 jest jeden. Licznik, więc ma wartość 1. Program rozkazuje napisać tekst i wstawić wartość licznika. Pętla się kończy. Program sprawdza, czy warunek jest spełniony. Aby pętla się zakończyła, wartość licznika musi wynosić 100. Nasz licznik aktualnie ma wartość 1. Zatem warunek nie został spełniony - program wraca do słowa „REPEAT”. I znowu - licznik zwiększa swoją wartość o 1, czyli ma już 2. Rozkazuje napisać tekst i wstawić licznik. Sprawdza warunek -warunek nie jest spełniony - i znowu „REPEAT” Licznik podnosi swoją wartość do 3 i tak dalej. Pętla się zakończy, aż wartość licznika będzie równa 100. Gdy pętla się zakończy, program wykonuje dalsze instrukcje (w tym wypadku jest to „READLN”). I tak oto wyjaśniłem wam działanie pętli.

Jednakże jeden program to trochę mało, aby was czegoś nauczyć. Zróbmy teraz inny. Zróbmy program, który będzie kazał napisać użytkownikowi hasło. Hasło będzie cyfrowe, załóżmy, że liczba 123. Użytkownik nie będzie mógł wyjść z programu, aż napisze poprawne hasło. No to do dzieła:

USES CRT;

VAR

haslo:longint;

BEGIN

REPEAT

clrscr;

writeln('Podaj hasło!');

read(haslo);

UNTIL haslo=123;

writeln('BRAWO! Odgadłeś hasło!');

readln;

END.

Jak widzimy, pętla ta nie zakończy się, gdy ktoś poda nieprawidłowe hasło. I tak za każdym razem. Napis „Brawo…” wyświetli się tylko wtedy, gdy ktoś poda prawidłowe hasło.

Spróbujmy teraz zrobić program z innej parafii. Naszym celem jest napisanie prostego alarmu. Program ma wytwarzać dźwięk podobny do alarmu. Dodatkowo, tak napiszemy ten program, aby alarm zapiał 10 razy. Do dzieła:

USES CRT;

VAR

ilosc,ton:longint;

BEGIN

ilosc:=0;

ton:=0;

REPEAT

ton:=ton+1;

IF ton=1000 THEN

BEGIN

ton:=1;

ilosc:=ilosc+1;

END;

Sound(ton);

Delay(1);

UNTIL ilosc=10;

Nosound;

END.

Jak widzicie zdeklarowałem dwie zmienne: „ilosc” i „ton”. Zmienna „ilosc” będzie nam mówiła ile razy alarm już zatrąbił. Zmienna „ton” decydować będzie to częstotliwości dźwięku. Najpierw zeruje oba zmienne. Później zaczynam pętle. Zmiennej „ton” zwiększam wartość (tak jak w poprzednich programach z pętlą). Program sprawdza, czy ta wartość równa jest sto. Na razie nie jest równa, więc program opuszcza instrukcję warunkową. Następnie przez 1/1000 sekundy wydobywa się dźwięk o częstotliwości ”ton”, czyli aktualnie 1. Pętla się zamyka. Następuje ponowne uruchomienie pętli, ponieważ wartość zmiennej „ilosc” nie jest równa 10. Kolejne zadania w pętli odgrywają dźwięk o coraz to wyższej częstotliwości. Daje to wrażenie alarmu. W pewnym momencie, zmienna „ton” jest już równa 1000, więc w pętli dokonuje się wstawiona tam instrukcja warunkowa. A w niej: „ton” przyjmuje wartość 1 oraz „ilosc” zwiększa swoją wartość o 1. Instrukcja warunkowa kończy się, a program odgrywa dźwięk o częstotliwości „ton”, czyli znowu 1. I znowu wszystko zaczyna się, z tym, że wartość zmiennej „ilosc” jest większa. Cały proces trwa do momentu, aż zmienna „ilosc” przyjmie wartość 10. Program wtedy ucichnie dzięki poleceniu „NoSound”. Skomplikowane, nieprawdaż? W praktyce usłyszysz 10 razy szybki wzrost częstotliwości. Da to efekt alarmu, zresztą - sam się przekonaj.

To teraz zajmijmy się poleceniem „WHILE..DO”, które jest drugą pętlą omawianą na tej lekcji. Nie różni się zbytnio od poprzedniej, natomiast jest nieco rzadziej używana. W poprzedniej pętli, zawsze to, co było ujęte w nią - wykonało się, co najmniej raz. Musi tak być, ponieważ warunek na zakończenie pętli był na jej końcu. Program działał w sposób, że najpierw wykonał pętle, a potem dopiero sprawdził, czy to jej koniec. Pętla „WHILE..DO”, najpierw sprawdza warunek, a potem dopiero, (jeżeli jest on spełniony) się wykonuje. Dlatego właśnie w tej pętli zaistnieć może sytuacja, że pętla w ogóle się nie włączy, gdy warunek nie będzie spełniony. Poza tym, program działa tak: dopóki warunek jest spełniony, wykonuj…, a nie jak poprzednio: wykonuj… aż warunek zostanie spełniony. Po słowie „WHILE” zawsze jest warunek. Potem następuje słowo „DO” i wpisujemy polecenia pętli. Po słowie „DO”, musimy zastosować „BEGIN”. Zatem wszystkie polecenia pętli muszą być ujęte w oddzielny blok. Wszystko zaraz się wyjaśni na konkretnym przykładzie (mam nadzieję).

Załóżmy, że chcemy zrobić prosty program, który pyta użytkownika o jakąś liczbę. Jeżeli ta liczba jest równa 10 lub 20, program wykonuje pętle. Jeżeli nie - program się wyłącza. Pętla polega na 10 krotnym wypisaniu słowa „Podałeś liczbę 10 lub 20”. Program głupi jest i nieprzydatny, ale jak do ćwiczeń, to dobry. Starymi sposobami, program ten można zrobić tak:

USES CRT;

VAR

liczba,licznik:longint;

BEGIN

clrscr;

writeln('Podaj jakąś liczbę');

read(liczba);

IF (liczba=10) OR (liczba=20) THEN

BEGIN

licznik:=0;

REPEAT

licznik:=licznik+1;

writeln('Podałeś liczbę 10 lub 20');

UNTIL licznik=10;

writeln;

END;

Halt;

END.

Jak widzimy program ma dwie zmienne: „liczba” i „licznik”. Użytkownik wprowadza liczbę. Jeżeli nie jest równa 10 lub 20, program opuszcza instrukcję warunkową, a zarazem pętle i dochodzi do polecenia „Halt”. Jeżeli liczba równa jest 10 lub 20, program wykonuje instrukcję warunkową - wypisuje 10 razy napis. A teraz powyższy program przekształćmy, tak aby można było użyć w nim pętli „WHILE..DO”. Będzie on wyglądał tak:

USES CRT;

VAR

liczba,licznik:longint;

BEGIN

clrscr;

writeln('Podaj jakąś liczbę');

read(liczba);

IF (liczba=10) OR (liczba=20) THEN

BEGIN

licznik:=0;

WHILE licznik<11 DO

BEGIN

licznik:=licznik+1;

writeln('Podałeś liczbę 10 lub 20');

END;

writeln;

END;

Halt;

END.

Pętla sprawdza warunek, czy licznik<11. Jeżeli tak, pętla się wykonuje. Wykonuje się tak długo, aż licznik nie będzie mniejszy od 11 (czyli, aż osiągnie wartość 11). Z tego wynika, że napis wyświetli się 10 razy. Jak widzimy, łatwiej jest operować pętlą „REPEAT” niż omawianą. Ale jak to mówią: „róbta co chceta”. Pamiętajcie, że w pętli „WHILE..DO” nie ma słowa „UNTIL”.

Do omówienia zostało jeszcze zagnieżdżanie pętli. Czy wiesz, że w pętle można wpisać jeszcze jedną pętle, a w nią następną i następną… i tak dalej. My nie będziemy zapętlali miliony razy, ale zrobimy bardzo fajny program, który nazywać się będzie „tabliczka mnożenia”. Jego zadaniem będzie wypisanie mnożeń, tzn. 1*1=1, 1*2=2, 1*3=3… aż dojdzie do 10*10=100. Wszystkie działania będą linijka pod linijką. Gdybyśmy chcieli to zrobić ręcznie, musielibyśmy zająć co najmniej 100 linijek tekstu (jedną na każde działanie), np:

writeln('4*3=12');

writeln('4*4=16');

writeln('4*5=20');

writeln('4*6=24');

writeln('4*7=28');

writeln('4*8=32');

writeln('4*9=36');

writeln('4*10=40');

writeln('5*1=5');

writeln('5*2=10');

writeln('5*3=15');

writeln('5*4=20');

i tak dalej...

Do tego celu zagnieździmy pętle. Tzn. wpiszemy drugą pętle „REPEAT” do już istniejącej. Najpierw zobaczcie na program, a potem sobie wyjaśnimy:

USES CRT;

VAR

a,b:longint;

BEGIN

clrscr;

writeln(' A oto tabliczka mnożenia:');

a:=0;

REPEAT

a:=a+1;

b:=0;

REPEAT

b:=b+1;

writeln(a,'*',b,'=',a*b);

delay(100);

UNTIL b=10;

UNTIL a=10;

END.

To teraz wyjaśnienie. Deklarujemy dwie zmienne: „a” i „b”. Zmienna „a” będzie pierwszą liczbą, którą będziemy mnożyć, zmienna „b” natomiast - drugą. (a*b). Po napisie, zerujemy zmienną „a”. Rozpoczynamy pętle ZEWNĘTRZNĄ. „a” zwiększa wartość o 1. Zerujemy „b”. Zaczynamy pętle „WEWNĘTRZNĄ”. „b” zwiększa wartość o 1. Program pisze: a*b=wynik. Zarówno „a” jak i „b” wynoszą 1, więc jest „1*1=1”. Napis trwa 1/10 sekundy. Wartość „b” nie jest równa 10, więc pętla zaczyna się jeszcze raz. Znowu „b” zwiększa wartość, ale „a” pozostaje takie samo. Jest zatem 1*2=2. Jak zauważyliśmy, wszystko idzie dobrze. Tabliczka mnożenia idzie przez 1 do momentu, aż „b” wyniesie 10 (1*10=10). Pętla wewnętrzna się kończy. Pamiętamy jednak, że cały czas jesteśmy w pętli zewnętrznej. Pętla zewnętrzna kończy się dopiero, kiedy „a” jest równe 10. W tej chwili „a” jest równe 1, więc pętla zewnętrzna zaczyna się od początku. Wartość „b” się zeruje i zaczyna się pętla wewnętrzna. Teraz wszystko mnoży się przez „2”. Zatem, w jednym poleceniu pętli zewnętrznej wykonuje się 10 razy pętla wewnętrzna. Pętla zewnętrzna wykonuje się 10 razy. Zatem końcowy napis będzie „10*10=100”. Tak oto stworzyliśmy tabliczkę mnożenia dzięki podwójnej pętli (zagnieżdżeniu). Polecenie „Delay” służy tylko temu, abyśmy zdążyli tę tabliczkę zobaczyć, bo bez niego program ją wypisze w mgnieniu oka.

I to tyle, jeśli chodzi o te dwie pętle. Nie zaglądaj nawet do następnej lekcji, dopóki nie zrozumiesz tej - a zwłaszcza ostatniego programu z tabliczką mnożenia. Pamiętaj, że pętle są wykorzystywane w 90% programów, więc bez nich ani rusz.

Zadanie domowe: Napisz program, który pyta użytkownika o jakąś liczbę. Po wprowadzeniu liczby przez użytkownika, program ma pomnożyć ją przez wszystkie liczby od 1 do 2000 i pokazać wyniki (linijka pod linijką).

PEŁNY KURS TURBO PASCALA - część VIII

pętle goto oraz FOR..TO..DO / FOR..DOWNTO..DO

W poprzednich pętlach tak naprawdę to nie wiadomo było ile razy się dana pętla wykona. Program mógł ciągnąć się w nieskończoność. Aby temu zapobiec, wymyślono pętle „FOR..TO..DO” oraz „FOR..DOWNTO..DO”. Oba pętle nie różnią się zbyt od siebie. Zacznijmy może od pętli „FOR..TO..DO”. Załóżmy, że chcemy zrobić program, który będzie 100 razy wypisywał imię użytkownika. Najpierw użytkownik wprowadza imię, a potem zaczyna się pętla, która polega na 100 - krotnym wypisaniu jego imienia schodząc o linie niżej. Stosując tu znaną ci już pętle, można zrobić to w ten sposób.

USES CRT;

VAR

imie:string;

ilosc:longint;

BEGIN

clrscr;

writeln('Jak masz na imię?');

read(imie);

ilosc:=0;

REPEAT

ilosc:=ilosc+1;

writeln(imie);

UNTIL ilosc=100;

readln;

END.

Jak widzimy, pętla jest prosta i nie trzeba jej dogłębnie omawiać. Program wypisze 100 razy imię użytkownika i się wyłączy. Zatem, w pętli tej z góry ustalona jest ilość wykonania instrukcji. Wiemy, że na 100% pętla wykona się 100 razy. Nic nie jest w stanie tego zmienić. Można, zatem, aby było prościej, zastosować pętle „FOR..TO..DO”. Najpierw obejrzyjcie program, a potem wyjaśnienia (program wykonuje to, co poprzedni).

USES CRT;

VAR

imie:string;

ilosc:longint;

BEGIN

clrscr;

writeln('Jak masz na imię?');

read(imie);

FOR ilosc:=1 TO 100 DO

BEGIN

writeln(imie);

END;

readln;

END.

Jak widzimy, zmienne pozostają te same, początek też ten sam. Pętla zaczyna się słówkiem „FOR”. Jest to jej początek. Po tym następuje przypisanie wartości jakiejś zmiennej. Zauważmy, że przypisujemy wartość dopiero tutaj, a nie przed pętlą. Następnie widzimy słówko „TO” i wpisujemy wartość zmiennej. Wpisaliśmy 100. Ilość ta informuje już nas, że pętla wykonywać będzie się 100 razy. Było to zatem polecenie, ile razy pętla ma się wykonać. Później następuje słówko „DO” i w oddzielnych blokach „BEGIN”, „END” wpisujemy polecenia pętli. Najważniejsze jest, że nie wpisujemy tam już czegoś takiego: „ilosc:=ilosc+1;”. Jest to zawarte po słowie „FOR”. Gdy pojedyncza instrukcja pętli się zakończy, wartość zmiennej „ilosc” przyjmuje wartość +1. Dzięki temu stworzyliśmy program, który mimo, że wygląda inaczej, działa tak jak poprzedni. Stymulując język polski, będzie to wyglądało tak: Od „imie” równa się 1 do 100, rób … Pamiętać trzeba o kilku ważnych rzeczach. Instrukcje pętli wpisujemy w oddzielne bloki - wielu o tym zapomina. Jak widzimy, pętla ta może się do czegoś przydać.

To w takim razie, po jakiego grzyba, wymyślono pętlę „FOR..DOWNTO..DO”??? Otóż, poprzednia pętla ZWIĘKSZAŁA wartość zmiennej o 1. Natomiast pętla „FOR..DOWNTO..DO” działa identycznie, z tym, że ZMNIEJSZA wartość zmiennej o 1. Programu już myślę, że nie trzeba robić - wszyscy wiedzą, o co chodzi. Zajmijmy się czymś bardziej skomplikowanym.

Na pewno pamiętacie zagnieżdżanie pętli z poprzedniej lekcji. Robiliśmy tam program „tabliczka mnożenia”. Spróbujmy zrobić program ten, ale za pomocą omawianej właśnie pętli. Spójrz, jak prościej wygląda on od poprzedniej wersji.

USES CRT;

VAR

a,b:longint;

BEGIN

clrscr;

FOR a:=1 TO 10 DO

BEGIN

FOR b:=1 TO 10 DO

BEGIN

writeln(a,'*',b,'=',a*b);

END;

END;

readln;

END.

Jak widzimy, do tabliczki mnożenia lepiej jest wykorzystywać pętlę „FOR..TO..DO”, aniżeli pętle „REPEAT”.

Ponieważ czas nagli, przechodzimy szybko do drugiej pętli omawianej w tej lekcji. Jest ona najprostsza do zrozumienia. Nie przypomina, bowiem żadnego zawiłego powtarzania, a przejście z jednego miejsca programu do drugiego. Załóżmy, że chcemy, aby program w którymś tam momencie wracał do początku programu lub gdzieś w jego środek. Dla przykładu posłużymy się programem, gdzie użytkownik będzie musiał wpisać hasło (coś już takiego było zdaje się). Jeżeli nie wpisze poprawnego hasła, program powtarza zapytanie. Jeżeli wpisze, program się wyłącza. Można ten program zrobić oczywiście za pomocą innych pętli już ci znanych, ale użyjemy tu nowego polecenia „GOTO” - nie mylić z „GOTOXY”. Polecenie to przenosi nas w dowolną część programu. Miejsce, gdzie przenieść ma nas to polecenie, musi być zaznaczone w kodzie programu. Poza tym, tak jak i zmienne - musi być wcześniej zdeklarowane. Miejsce takie nazywa fachowo się „kotwicą” i tak będziemy je nazywać. Deklarować kotwice najlepiej jest zaraz po zmiennych. Zmienne deklarowaliśmy poleceniem „VAR”, kotwice natomiast deklaruje się poleceniem „LABEL”. W praktyce wygląda to tak:

USES CRT;

VAR

zmienna1:longint;

zmienna2:string;

LABEL miejsce1;

BEGIN

(i tak dalej...)

Jak widzimy, zadeklarowałem dwie zmienne (ale mniejsza z nimi) oraz kotwice o nazwie „miejsce1”. Kotwice deklarujemy po słowie „LABEL” i nie wpisujemy żadnych typów (po prostu je wymieniamy po przecinku bez żadnych dwukropków). Na końcu pamiętać trzeba jednak o średniku. Teraz mamy już zadeklarowaną kotwice o nazwie „miejsce1”, więc bez problemu możemy ją użyć (a raczej wstawić). Gotowy już program z hasłem, wygląda następująco:

USES CRT;

VAR

haslo:longint;

LABEL miejsce1;

BEGIN

miejsce1:

clrscr;

write('Podaj poprawne hasło: ');

read(haslo);

IF haslo<>123456 THEN goto miejsce1;

writeln('Brawo! Odgadłeś hasło!');

readln;

END.

W powyższym przykładzie kotwica o nazwie „miejsce1” znajduje się na początku programu. Kotwice mogą znajdować się również w innych miejscach. Kotwice wstawia się do programu tylko jeden raz. Wstawiamy jej nazwę i dwukropek. Później komputer czyści ekran i pyta użytkownika o hasło. Hasło jest równe 123456. Jeżeli ktoś wprowadził błędne hasło, komputer wykonuje instrukcję warunkową. W niej ma rozkaz „GOTO miejsce1”, co oznacza „idź do miejsce1”. Komputer nie patrząc praktycznie na dalszą część kodu, przechodzi do kotwicy tak właśnie oznaczonej. I znowu: czyści ekran, pyta urzytkow… i tak dalej. Zatem, napis z brawami nie ukaże się dopóty użytkownik wprowadzi poprawne hasło (czyli 123456). Na tym właśnie polega polecenie „GOTO”.

No i to by było na tyle jeśli chodzi o tą lekcję. Moim zdaniem, jeżeli przeczytałeś już wszystkie wcześniejsze lekcje i tą - jesteś na dobrej drodze, aby zostać programistą. Oczywiście, twoja wiedza jest jeszcze bardzo uboga, dlatego zapraszam do lekcji następnej.

POWRÓT DO STRONY GŁÓWNEJ

PEŁNY KURS TURBO PASCALA - część X

Komentarze, zmienne, stałe

To nie powinna być trudna lekcja - dam wam przerwę intelektualną za poprzednią (ależ te funkcje i procedury musiały zamącić wam w głowie). Zacznijmy od komentarzy. Komentarze w programie służą praktycznie do niczego. Komputer je całkowicie ignoruje. W takim razie - po kiego grzyba są te komentarze??? Otóż ktoś wymyślił je dla nas samych. Załóżmy, że mamy dłuuuuugi program. Nie pamiętamy więc gdzie co się zaczyna. Szukanie w stogu siana może być nieco kłopotliwe, dlatego podczas tworzenia długich programów zalecam stosowanie komentarzy. Program nie zwraca na nie uwagi, a my możemy się w nim bardziej zorientować. Przykładowy fragment programu z wykorzystaniem komentarza wygląda tak:

USES CRT;

VAR {Deklaracja zmiennych}

zmienna1:longint;

BEGIN {Początek programu}

clrscr;

writeln('Podaj jakąś liczbę');

read(zmienna1);

writeln('Liczba ta wynosi: ',zmienna1);

readln;

END. {Koniec programu}

Jak każdy widzi, komentarze pisze się w nawiasach sześciennych. Chyba nie muszę tutaj dawać jakichś specjalnych wyjaśnień, dodam tylko, że komentarze również możecie zamieszczać w komentarzach. Wystarczy wszystkie komentarze zawarte w sześciennych nawiasach umieścić w takim oto kwiatku „(*” , a na zakończenie „*)”. Czyli jest to nawias zwykły i gwiazda. To tyle jeśli chodzi o temat komentarzy.

A teraz temat stałych. Nie jeden raz pewnie w naszych wszystkich wcześniejszych programach występowały zmienne, które podczas działania programu zachowywały swoją wartość. Jak sama nazwa mówi, „zmienna” to coś co się zmienia. Po co więc stosować zmienne do wartości, które i tak będą ciągle takie same. Takie wartości możemy deklarować poleceniem „CONST”, a nazywamy je stałymi. Ich deklaracja ma miejsce przed głównym programem. Nie stosujemy tam żadnych typów - tylko nazwa i wartość. Wartości mogą być różne - najważniejsze to dana liczba bądź tekst, np.:

USES CRT;

CONST

abc=500;

tekst1='jakiś tekst';

BEGIN

polecenia...

END.

Zadeklarowaliśmy 2 stałe: stałą „abc” oraz stałą „tekst1”. Pierwsza stała ma wartość 500, więc jak widać można ją wykorzystywać do różnych działań matematycznych. Druga stała ma przypisany tekst. Jej wywołanie w programie da właśnie taki tekst. Stałe wywołuje się tak jak zmienne. Zauważmy jeszcze budowę deklaracji. Nie stosujemy dwukropka jak przy zmiennych, tylko znak równości. Pamiętamy też, że wartość stałej musimy podać w cudzysłowu, jeżeli jest to tekst. Jeżeli chodzi o stałe, to chyba wszystko. Warto moim zdaniem je stosować w programach, gdzie wielokrotnie występuje jakaś liczba. Pomyślcie, co będzie, gdy trzeba będzie tą liczbę zmienić. Zamiast niej, zatem lepiej wstawić stałą, a zmiany późniejsze będą tylko zmianą wartości stałej.

No i ostatni temat - również niezbyt obszerny, - czyli zmienne. Podczas swojej wędrówki wśród wcześniejszych lekcji nauczyłeś się już dwóch typów zmiennych. Były to „longint” oraz „string”. Dzisiaj poznasz wszystkie typy (noo prawie wszystkie). Zatem zaczynajmy (poniżej macie typy zmiennych, jakie możecie używać oraz ich krótki opis):

typ LONGINT

Jest to znany ci już typ liczbowy. Nie przejmowaliśmy się zbytnio jego zakresem, gdyż mieści liczby od -2147483648 do 2147483647, więc jak widać powinien każdemu wystarczyć. Jest typem liczb całkowitych i tylko je zapamiętuje.

typ INTEGER

Też jest typem liczb całkowitych, ale o znacznie mniejszym zakresie (-32768..32767). Jeżeli nie potrzebujesz tylu liczb co w typie LONGINT, używaj INTEGER w celu zwiększenia szybkości programu i zaoszczędzenia pamięci.

typ SHORTINT

Czyli krótki typ całkowity. Mieści liczby z przedziału -128, 127.

typ BYTE

Liczba naturalna od 0 do 255. Typ mało stosowany, gdyż nie daje możliwości zapamiętywania liczb ujemnych.

typ WORD

Typ podobny do BYTE, z tym że zapamiętuje liczby z przedziału 0..65535.

typ ReAL

Typ liczb rzeczywistych. Liczby rzeczywiste to zarówno ujemne jak i ułamki. Typ ten wydaje się być dobrym typem, poza tym mieści on liczby o wiele większe od typu LONGINT, mimo to związane są z nim pewne problemy. W dalszej części tej lekcji znajduje się akapit dogłębnie omawiający ten typ, więc radzę zajrzeć.

typ STRING

Typ zapamiętujący nie liczbę, a tekst. Nie znaczy to oczywiście, że typ ten nie zapamięta liczb - zapamięta, ale nie jako liczby, a jako ciąg znaków. Typ ten ma jednak swoje ograniczenia - ciąg znaków nie może być dłuższy niż 255 znaków.

typ CHAR

Typ ten działa podobnie jak STRING, z tym, że zapamiętuje tylko 1 znak. Można go interpretować w dwoisty sposób - znak jako znak, albo jako numer w tablicy ASCII. W sumie - wychodzi na jedno i to samo.

Z powyższych typów zmiennych, gdy chcemy robić jakieś skomplikowane obliczenia stosujemy typ REAL. Jak już wspomniałem wiąże się z tym pewien kłopot (a tak właściwie to kilka kłopotów). Po pierwsze, gdy chcemy wprowadzić liczbę typu REAL do komputera, robi się to normalnie. Gorzej już ma się sytuacja, gdy chcemy taką liczbę wyświetlić. Zróbmy program, który najpierw pyta użytkownika o jakąś liczbę, a potem ją wyświetla. Spróbujcie najpierw zrobić ten program wykorzystując zmienną LONGINT lub jakąś inną całkowitą, a potem spróbujcie z REAL. Wynik np. liczby 3 będzie wyglądał miej więcej tak: „3.0000000E+00”. Jest to tzw. postać naukowa, dla nas raczej niewygodna. Dlatego właśnie używać należy tu dwukropka. Jeżeli chcemy, aby liczba wyświetlona była „normalnie” podajemy nazwę zmiennej, a następnie dwukropek i jakąś liczbę. Ta liczba będzie decydować, ile miejsc po przecinku ma pokazać komputer. Jeżeli program ma podzielić 1 na 2, wynik bez naszych dekoracji będzie paskudny, więc można napisać: „writeln(1/2:2)”. Znaczy to, że program ma napisać ile jest 1 podzielić na 2 korzystając z dwóch miejsc po przecinku. Wynik będzie miej więcej taki „0.50”, a nie taki: „0.500000E+00”. Chyba ładniej wygląda. Możemy również zastosować jeden dwukropek, liczbę, drugi dwukropek i drugą liczbę. Wtedy pierwsza liczba decydować będzie ile znaków ma być przed przecinkiem, a druga - ile po. Następna sprawa to sposób wprowadzania liczb REAL. Dodatnie liczby wprowadza się normalnie. Jak się pewnie domyślasz - ujemne z minusem na początku. A co jeśli chcemy wprowadzić ułamek, np. 1,5 (półtora)? Zarówno podczas wprowadzania, jak i używania w programach nie stosujemy przecinka tylko KROPKI. Nie pytajcie dlaczego tak jest - po prostu stosuje się kropkę. Kolejna sprawa to tzw. błędy. Wyrażenie 1/3*3, wcale nie jest równe 3, chociaż może się tak wydawać. Jeżeli podzielimy 1 na 3 wyjdzie nam nieskończony ciąg (0,33333333333333333…). Jeżeli teraz pomnożymy to przez 3, jak widać nie ma szans żeby wyszło 3. Trzeba zatem na to uważać. Pamiętaj, że REAL to ułamek dziesiętny, a nie ułamek zwykły. Można również wykorzystać polecenie ROUND, które służy do zaokrąglania liczb. Stosuje się tak jak inne polecenia matematyczne (polecenie ROUND i w nawiasie, to co komputer ma zaokrąglić). Jak widzimy, zmienne typu REAL są dobre, ale trzeba z nimi uważać.

PEŁNY KURS TURBO PASCALA - część XIV

inne polecenia

W tej części kursu poznasz garść kolejnych poleceń, które chociaż nie są szeroko stosowane, jednak warto je znać. Zatem, zaczynajmy:

CHR

Jak pewnie wiesz, każda litera bądź cyfra czy jakikolwiek znak z klawiatury ma swój numer w międzynarodowej tablicy ASCII. Są tam zawarte wszystkie znaki od 1 do 255. Dla przykładu, litera „F” ma numer 70. Zatem „F” można zapisać na dwa sposoby (jako zwykłe „F” lub numer 70 odpowiednio zapisany). Poniższy zapis:

write('F');

Znaczy to samo co:

write(chr(70));

Można to zrobić w jeszcze łatwiejszy sposób, zastępując CHR jako „#”, czyli krzyżyk. Jest to zatem:

write(#70);

ORD

Polecenie to działa odwrotnie jak CHR (zamienia znaki na liczby).

write(ord('F'));

Powyższy rozkaz da po prostu liczbę 70.

INC

Jest to instrukcja zwiększająca wartość liczby o 1. Na przykład, gdy jakaś zmienna jest równa 3, zastosowanie INC(nazwa zmiennej) da nam 4. Poza tym, INC działa również na literach (z „a” zrobi się „b” itd.). Przykład jest chyba zbędny.

DEC

Działa odwrotnie do INC, czyli zmniejsza wartość i 1 (działa również na literach).

TEXTCOLOR

Zamienia kolor tekstu na ten, który będzie podany w nawiasie (np. textcolor(red) da nam tekst barwy czerwonej). Dostępne kolory to: black (czarny), blue (niebieski), green (zielony), cyan (turkus), red (czerwony), magenta (karmazynowy), brown (brązowy), lightgray (jasnoszary), darkgray (ciemnoszary), lightblue (jasnoniebieski), lightgreen (jasnozielony), lightcyan (jasny turkus), lightred (jasnoczerwony), lightmagenta (jasnokarmazynowy), yellow (żółty), white (biały - standartowy). Zmiana koloru wymaga modułu CRT.

TEXTBACKGROUND

Czyli zmiana koloru tła (używa się tak jak TEXTCOLOR). Do wybrania możliwe jest osiem kolorów: black (czarny - standartowy), blue (niebieski), green (zielony), cyan (turkus), red (czerwony), magenta (karmazynowy), brown (brązowy), lightgray (jasnoszary). Zmiana koloru tła wymaga modułu CRT.

UPCAS

Polecenie to zamienia małą literę na dużą. Jeżeli użytkownik wprowadzi cyfrę - nie następuje żadna zamiana. Przykłady: UpCase('a') = 'A', UpCase('B') = 'B', UpCase('6') = '6'

STR

Zamienia liczby na zmienne typu STRING. Na przykład, jeżeli chcemy zamienić zmienną o nazwie „a” typu WORD na zmienną o nazwie „x” typu STRING, piszemy: str(a,x) i problem z głowy.

I to chyba koniec dodatkowych poleceń wartych waszej uwagi. Zapraszam do następnej lekcji.

POWRÓT DO STRONY GŁÓWNEJ

---