Skróty klawiaturowe programu Turbo Pascal F9

Skróty klawiaturowe programu Turbo Pascal
F9- kompilacja
Ctrl+F9- uruchamianie programu
F2 - zapis na dysku
F3- odczyt tekstu programu z dysku
Alt+F5- obejrzenie wyników działania programu
Alt+X - koniec pracy z programem
Alt+Enter- pełny ekran / lub zmniejszenie pełnego ekranu
Pakiet Turbo Pascala dysponuje edytorem programów o moŜliwościach zbliŜonych do zwykłych edytorów.
Uruchamia się on automatycznie, gdy otwieramy plik z kodem źródłowym programu.
Po oknie edycji poruszamy się za pomocą strzałek, myszki oraz następujących klawiszy:
•
home - przesuwa kursor na początek wiersza;
•
end - przesuwa kursor na koniec wiersza;
•
page up ( pgup ) - przesuwa kursor o jedną stronę do góry;
•
page down ( pgdn ) - przesuwa kursor o jedną stronę w dół;
•
ctrl + home - przesuwa kursor do pierwszego wiersza w oknie;
•
ctrl + end - przesuwa kursor do ostatniego wiersza w oknie.
Klawisz backspace ( bksp ) usuwa znak przed kursorem, natomiast klawisz delete ( del ) usuwa jeden znak
za kursorem. Klawisz insert ( ins ) słuŜy do wyboru trybu wstawiania lub nadpisywania. Kombinacja ctrl + y
słuŜy do usuwania wiersza zawierającego kursor. Ostatnie zmiany w tekście moŜna cofnąć poprzez wybór
komendy Undo ( alt + bksp ) z menu Edit .
Edytor umoŜliwia takŜe dokonywania operacji na blokach tekstu:
•
trzymając shift i wciskając strzałki moŜemy zaznaczać fragment tekstu; moŜemy to równieŜ osiągnąć
trzymając przyciśnięty klawisz myszy i poruszanie nią ;
•
polecenie Cut ( shift + del ) z menu Edit wycina zaznaczony tekst i wstawia go do pamięci;
•
polecenie Copy ( ctrl + ins ) z menu Edit kopiuje zaznaczony tekst d o pamięci;
•
polecenie Paste ( shift + ins ) z menu Edit wstawia za kursorem tekst z pamięci;
•
polecenie Clear ( ctrl + del ) z menu Edit usuwa zaznaczony tekst, lecz nie umieszcza go w pamięci;
•
polecenie Show Clipboard z menu Edit otwiera okno zawierające tekst zawarty w pamięci
1
Struktura programu
KaŜdy nie trywialny program powinien składać się z danych, instrukcji i komentarzy . Dane to obiekty na
których program przeprowadza operacje (liczby, teksty i ich kombinacje). Instrukcje to kolejne operacje,
które program ma wykonać na danych. Komentarze nie wpływają na przebieg działania programu, słuŜą
jedynie poprawieniu czytelności kodu. Program powinien składać się z następujących sekcji :
program nazwa_programu;
Słowo kluczowe oznaczające, iŜ dany plik zawiera program w języku Pascal. Jednocześnie nadaje mu
unikalną nazwę (nie ma to nic wspólnego z nazwą pliku w którym program jest przechowywany).
uses modul_1, modul_2, ... ;
Jest to instrukcja dołączająca zewnętrzne biblioteki zawierające dodatkowe procedury i funkcje,
których moŜna będzie uŜyć we własnym programie.np.:
uses crt,graph,dos;
dołącza biblioteki zawierające kolejno funkcje tekstowe, graficzne i systemowe.
type nazwa_nowego_typu = definicja_nowego_typu;
Przy pomocy tego słowa kluczowego moŜemy utworzyć nowe typy danych na podstawie tych juŜ
istniejących (najczęściej są one bardziej skomplikowane).np.:
type calkowita=integer;
przyporządkuje typowi calkowita standardowy typ integer .
const nazwa_stalej : typ_stalej = wartosc;
Deklaracje stałych.np.:
const LIMIT=10000;
definiuje ciąg LIMIT jako zamiennik dla wartości 10000 w kodzie źródłowym.
var nazwa_zmiennej : typ;
Deklaracja zmiennych globalnych uŜytych w programie. Będą one widoczne (moŜna się do nich
odwoływać) w kaŜdym miejscu programu.
procedure nazwa_podprogramu[(parametr1; parametr2;...)];
function nazwa_funkcji[(parametr1;parametr2;...)]:typ_zwracany;
W tym miejscu naleŜy umieścić definicje własnych funkcji i procedur uŜytych w programie.
begin
Blok programu głównego. Uwaga : koniec tego bloku jest zapisywany słowem kluczowym end. z
kropką na końcu.
end.
2
Procedura Write
SłuŜy do wypisania na ekran liczby/tekstu:
Program pierwszy;
Const
jakas_stala=999;
Var
jakas_zmienna:Word;
Begin
jakas_zmienna:=448;
Write(123);
{1}
Write('bzdura');
{2}
Write(4*8);
{3}
Write('4*8');
{4}
Write(jakas_stala); {5}
Write(jakas_zmienna); {6}
Write(jakas_zmienna+12); {7}
Write(3/4);
{8}
End.
Program wypisze na ekranie liczbę 123 {1}, tekst 'bzdura' {2}, wynik działania matematycznego 32
{3}, tekst '4*8' {4}, stałą o wartości 999 {5}, zmienną do której została wprowadzona liczba 448 {6}, oraz tą
samą zmienną powiększoną o 12 czyli 460 {7}.
W tym momencie pojawia się dziwna rzecz, w linii {8} zamiast spodziewanego wyniku 0.75
wyświetla nam program liczbe 7.5000000000E-01 ale jest to nic innego jak liczba przed literką E pomnoŜona
o 10 do potęgi takiej jaka się znajduje po literce E czyli 7.5000000000 * 10 -01 i jest to dokładnie 0.75. Aby
wynik wyświetlany był jednak w bardziej czytelnej formie, do której jesteśmy na co dzień przyzwyczajeni
wystarczy uŜyć zapisu formatującego wyświetlane dane, a dokładniej to naleŜy dodać dwie cyferki
oddzielone od siebie dwukropkami np:
Write(3/4:8:4);
Znaczy to: wyświetl liczbę ograniczając wyświetlanie do 8 znaków przed kropką i 4 po kropce, dzięki temu
otrzymamy łatwo czytelny wynik 0.7500
3
Procedura WRITE nie wykonuje nic więcej oprócz wypisania wartości z pomiędzy nawiasów
dlatego wszystkie te wyświetlane wartości będą znajdowały się w jednej linii.
MoŜna równieŜ podać wszystkie te parametry naraz, oddzielając je przecinkami:
Const
jakas_stala=999;
Var
jakas_zmienna:Word;
Begin
jakas_zmienna:=448;
Write(123,'bzdura',4*8,'4*8',jakas_stala,jakas_zmienna,jakas_zmienna+12,3/4:8:2);
End.
Procedura WriteLn
Podobnie jak WRITE, WRITELN wypisuje wartość z pomiędzy nawiasów, ale jeszcze dodatkowo po
wypisaniu tej wartości przechodzi do następnej linii.
Begin
WriteLn(123);
WriteLn('bzdura');
{1}
{2}
WriteLn('');
{3}
WriteLn;
{4}
WriteLn(4*8);
{5}
End.
W tym przypadku w KOLEJNYCH LINIACH zostaną wyświetlone wartości: liczba 123 {1} , tekst
'bzdura' {2}, pusty ciąg znaków '' {3} ( czyli niczego nie wyświetli i przejdzie do następnej linii ), kolejną
pustą linię {4} ( po prostu procedura jest wykonywana podobnie jak w {3} z pustym łańcuchem znaków ) i
wynik działania 32 {5}. Podobnie jak w procedurze Write parametry moŜna podawać oddzielone
przecinkami:
Begin
WriteLn(123,'bzdura','',,4*8);
4
End.
Zwróć uwagę, Ŝe w tym przypadku jak pomineliśmy pusty ciąg znaków i po poprostu wpisaliśmy kolejny
przecinek ( podobnie jak w {4} ) kompilator wyrzuci nam błąd. Prawidłowym zapisem natomiast jest:
Begin
WriteLn(123,'bzdura','','',4*8);
End.
Procedura Read
Pozwala na wprowadzenie do zmiennej wartość podawaną z klawiatury w czasie działania programu:
Var
zm1:String;
zm2:Word;
Begin
Read(zm1);
{1}
Read(zm2);
{2}
Read;
{3}
End.
Program czeka na wprowadzenie dwóch zmiennych, ZM1 typu STRING {1} oraz ZM2 typu WORD
{2}, jeŜeli natomiast wywołamy tą procedurę bez Ŝadnych parametrów {3} to program czeka w tym
momencie na wciśniecie klawisza Enter. W przypadku wprowadzania zmiennych trzeba uwaŜać na kilka
rzeczy:
1) JeŜeli program będzie oczekiwał liczby a my podamy mu tekst, to zastanie on zatrzymany i wyświetli błąd
2) JeŜeli czeka np. na liczbę typu WORD, a podamy mu przekraczającą jej typ liczbę 70000, to w zmiennej
znajdzie się całkiem inna liczba której się tam niespodziewaliśmy w tym przypadku będzie to 4464 będzie to
tzw. przekręcenie licznika :)
3) JeŜeli czeka na typ STRING a podamy liczbę, to uzna tą liczbę za tekst tak więc nie będzie moŜna jej
uŜywać np. w działaniach matematycznych. (Wprawdzie jest funkcja przekształcająca liczbę umieszczoną w
typie STRING na WORD, INTEGER itd. ale opowiem o niej dopiero później, niemniej istnieje taka i nazywa
się VAL).
Procedura READ przyjmuje kolejne zmienne w tej samej linii jedna za drugą.
5
Procedura ReadLn
Podobnie jak READ procedura ta pozwala na wprowadzenie do zmiennej wartość podawaną z klawiatury w
czasie działania programu, z tym, Ŝe po przyjęciu wartości program przechodzi do następnej linii:
Var
imie:String;
Begin
Write( 'Jak masz na imie ? : ' );
ReadLn( imie );
WriteLn;
{1}
{2}
{3}
WriteLn( 'Witaj ' , imie , '!' );
{4}
Write( 'Wcisnij Enter...' );
ReadLn;
{5}
End.
Programik ten wypisuje tekst {1} i czeka na wprowadzenie zmiennej IMIE {2}, następnie robi linijkę odstępu
{3} i wypisuje tekst, zmienną i znowu tekst {4}. Na sam koniec czeka dodatkowo na wciśniecie klawisza
Enter {5}.
Procedura ClrScr
Składnia: ClrScr; [CRT]
Usuwa wszystkie znaki z ekranu tekstowego (czyści go) i ustawia kursor w pozycji 0,0 (lewy górny róg
ekranu)
Procedura GotoXY
Składnia: GotoXY(x,y:byte); [CRT]
Procedura ta pozwala na umieszczenie kursora (miejsca, od którego np. będą wyświetlane wartości przez
Write), w dowolnym miejscu ekranu, procedura ta znajduje się w bibliotece CRT:
Uses CRT;
Begin
6
GotoXY(20,10);
Write('Ten tekst rozpoczyna się w 20 kolumnie i 10 wersie');
End.
W tym programie procedura GotoXY nakazuje przenieść kursor do 20 wiersza i 10 kolumny i wyświetlić
tekst.
Procedura Sound
Składnia: Sound(CZE:word); [CRT]
Włącza dźwięk o częstotliwości CZE ( liczba typu word ) emitowany przez głośnik komputera. Z własnych
praktyk zauwaŜyłem Ŝe dźwięk o częstotliwości 3160 jest "trochę" denerwujący :)
Procedura NoSound
Składnia: NoSound; [CRT]
Wyłącza dźwięk emitowany przez głośnik komputera, włączony uprzednio przez SOUND.
Procedura Delay
Składnia: Delay(CZAS:word); [CRT]
Wstrzymuje program na określoną (zmienna CZAS) ilość milisekund (1000 milisekund=sekunda), przydatne
np. przy procedurze Sound
Uses CRT;
Begin
Sound(2000);
Delay(1000);
NoSound;
End.
Program1
program witaj;
uses crt;
begin
clrscr;
writeln('Witaj szkolo!');
7
readln;
end.
Program 2
program czesc;
uses crt;
begin
clrscr;
write ('czesc');
writeln ('Jak sie masz?');
writeln ('Czy jestes gotowy na Pascala?');
readln;
end.
Program 3
program wizytowka;
uses crt;
begin
clrscr;
writeln ('Gall Anonim');
writeln ('----------------------- ');
writeln ('Klasa I SP');
writeln ('Programowanie strukturalne i obiektowe');
readln;
end.
Program 4
program liczby;
uses crt;
begin
clrscr;
writeln ('Mnozenie dwoch liczb 50*40:',50*40);
writeln ('oraz dzielenie liczb 2400/8:',(5+3)*(2-6 div 2));
readln;
end.
Program 5
program zmienne;
uses crt;
var a:integer;
b:Integer;
x:real;
begin
clrscr;
writeln ('liczba a:',a);
writeln ('liczba b:',b);
writeln ('liczba x:',x);
readln;
end.
Program 6
8
program obliczenia;
uses crt;
var a,b:integer;
begin
clrscr;
a:=33;
b:=0;
writeln ('a=',a);
writeln ('b=',b);
writeln ('a+b=',a+b);
writeln ('a-b=',a-b);
writeln ('a/b=',a/b);
writeln ('a*b=',a*b);
writeln ('a div b=',a div b);
writeln ('a mod b=',a mod b);
readln;
end.
Program 7
program obwod_kola;
uses crt;
const
pi=3.14159;
var
promien, obwod,pole:real;
begin
clrscr;
promien:=4.9;
pole:=pi*promien*promien;
obwod:=2*pi*promien;
writeln ('pole _kola=',pole);
writeln ('obwod_kola=',obwod);
writeln ('zaokraglona=',round(obwod));
writeln ('przycieta=',trunc(obwod));
readln;
end.
9