Delphi - cz. 2
Witam ponownie! Dzisiaj dalej będziemy kontynuować naukę Delphi. W poprzednim rozdziale wyjaśniałem, co to są zmienne. Teraz zajmiemy się stałymi:
Stale
Stale jak sama nazwa wskazują mogą przybierać określaną wartość, której nie można zmieniać. Oto przykład deklaracji stałych:
const
MojaStala = 'Moja pierwsza stała';
begin
{ .... }
Korzystając z okazji chciałbym także omówić komentarze. Komentarze to cześć kodu, która nie jest brana pod uwagę przez kompilator. Można wpisywać tam swoje notatki, uwagi itp. Komentarze wpisuje się pomiędzy znaki:
{ i } oraz takie: (* i *). Możliwy jest także komentarz jednej linii. W takim wypadku stosuje się znak:
// tu wpisz komentarz
To tyle, jeśli chodzi o komentarze, ale przecież mieliśmy omawiać stale. Jak zapewne zauważyłeś zmienne deklaruje się po słowie "const". Przy wypisywaniu zmiennych nie trzeba również podawać typów zmiennych. Możesz robić tak:
const
MojaStala : String = 'Moja pierwsza stała';
ale chyba wygodniej jest robić tak:
const
MojaStala = 'Moja pierwsza stała';
Procedury i funkcje
W Delphi cały blok kodu zawarty jest w procedurach, które są następnie wywoływane po zajściu jakiegoś zdarzenia. Możliwe jest deklarowanie własnych procedur i funkcji. Funkcja różni się tym od procedur, ze zwraca rezultat. Być może wyda Ci się to nie zrozumiale wiec stwórzmy prosty programik, który wykorzystuje funkcje.
1. Umieść na formularzu komponent "Button".
2. Teraz przełącz się do edytora kodu ( F12 ).
3. Odnajdź słowo "private". Pod nim dopisz taka oto linie kodu:
function MojaFunkcja(X, Y : Integer) : Integer;
Tak przedstawia się budowa funkcji. Najpierw słowo "function", które "mówi" kompilatorowi, ze ma do czynienia z funkcja. Następnie w nawisanie przedstawiane są dwie
zmienne typu "Integer". Można się obyć bez tych zmiennych, lecz do tego przykładu potrzebne nam będą te właśnie zmienne. Na samym końcu typ wyniku, czyli
"Integer". Procedura wyglądałaby w ten sposób:
procedure MojaProcedura(X, Y : Integer);
Właśnie tym różni się procedura - nie zwraca rezultatu. Ok, teraz najedź kursorem na nazwę funkcji. Naciśnij kombinacje klawiszy: Ctrl + Shift + C - deklaracja funkcji
dodana zostanie w sekcji "Implementation". To tutaj wpiszemy swój kod. Będzie to jedynie jedna linia:
function TForm1.MojaFunkcja(X, Y: Integer): Integer;
begin
// rezultat funkcji:
Result := X + Y;
end;
Tak przedstawia się nasza funkcja. Słowo "Result" śluzy do zwracania wyniku. Rezultatem działania takiej funkcji będzie dodanie do siebie dwóch zmiennych: X i Y.
Być może na początku wyda Ci się to niejasne. W razie jakichkolwiek problemów i pytań pisz: boduch@poland.com
Dobra teraz przełącz się do formularza ( F12 ). Na formularzu umieszczony jest przycisk - naciśnij go dwukrotnie. I znów zostałeś przełączony do edytora kodu. Ta
procedura wywoływana będzie wtedy, gdy użytkownik naciśnie na przycisku. Wpisz takie cos:
ShowMessage(IntToStr(
MojaFunkcja(20, 20)));
No tak. Tutaj należy się parę, słow. komentarza. Funkcja "ShowMessage". Ta funkcja wyświetla komunikat z tekstem i przyciskiem OK. Np.:
ShowMessage('Cześć, jestem komunikatem!');
W tym wypadku, jeżeli wpiszesz powyższy kod do jakiejś procedury spowoduje ona wyświetlenie okna dialogowego z tekstem wpisanym w apostrofach. Tekst musi
być typu "String", a funkcja "MojaFunkcja" zwraca wynik w postaci zmiennej "Integer". A przecież zmienna "String" to nie to samo, co "Integer"? Tutaj z pomocą
przychodzi funkcja, „IntToStr", która KONWERTUJE zmienna "Integer" do zmiennej, „String". Jeżeli już skonwertowaliśmy te funkcje pozostaje jeszcze wpisanie nazwy
"MojaFunkcja" i w nawiasach wpisanie dwóch zmiennych X i Y. Uruchom program ( F9 ) i naciśnij na przycisk - wyświetli się okienko z cyferka 40. Wszystko to za
sprawa funkcji "MojaFunkcja".
Klasy
Przyjrzyj się swojemu modułowi - po słowie "type" następuje taka linia: TForm1 = class(TForm). Oznacza ona KLASE, w tym wypadku "TForm1". Istnieje możliwość
deklarowania własnych klas, ale tym na razie nie będziemy się zajmować. Po deklaracji typów następuje wypisanie wszystkich komponentów zawartych na formularzu.
Jak już opisałem w poprzednim rozdziale po lewej stronie następuje nazwa komponentu ( modyfikowana w Inspektorze Obiektów ), a po prawej typ komponentu.
Następnie następują tajemnicze słowa: "private" i "public". W tych sekcjach możesz wpisywać swoje zmienne i procedury oraz funkcje. Tak tutaj tez możesz wpisywać
swoje zmienne, które "widoczne" będą w całym module. Co to znaczy? Jeżeli w procedurze wpiszesz jakąś zmienna np.: S : String i umieścisz na formularzu nowy
komponent "Button", a następnie klikniesz na niego dwukrotnie i spróbujesz zmodyfikować zmienna S. Co wtedy? Kompilator wykaże błąd: Nie wie, co to jest zmienna
S. A gdy teraz umieścisz te zmienna w sekcji "private" będziesz ja mógł modyfikować we wszystkich procedurach.
Zapytasz zapewne:, „Po co są te dwie sekcje: private i public". Dobre pytanie. W sekcji "private" umieszczane mogą być deklaracje funkcji, które nie będą widoczne w
innych modułach. Jeżeli masz nowy formularz ( "File" -> "New Form" ) i próbujesz wykorzystać te funkcje w drugim formularzu to kompilator nie będzie wiedział, co to
jest ta procedura, która próbujesz wykorzystać. Gdybyś umieścił deklaracje w sekcji "public" wszystko byłoby OK.
Operatory
Operatory są jedna z najczęściej używanych funkcji w Pascalu. Oto najpopularniejsze operatory:
= znak równości
< znak mniejszości
> znak większości
<> różne od...
:= operator przypisania
and operator and ( ang: "i" ).
or operator or ( ang. "lub" ).
not operator not ( ang. "nie" );
+ dodawanie
- odejmowanie
* mnożenie
/ dzielenie
div dzielenie całkowite.
Z większością z nich zetkniesz się później. Ja omówię tylko niektóre. Dodawanie, odejmowanie, mnożenie nie wymaga chyba objaśnienia. Parę słow. powiem o
operatorze "div". Otóż "obcina" ona resztę z dzielenia - np.:
5 div 2; // takie działanie zwróci wynik w postaci cyfry 2.
Przeczytaj poniższy podpunkt, a wszystko stanie się jasne:
Instrukcje: "if", "then"
Instrukcje te służą do porównania typów. Oto przykładzik:
var
X : Integer;
begin
X := 10;
if X = 10 then
ShowMessage('Tak to cyfra 10! ');
Jeżeli chciałbyś przetłumaczyć to dosłownie na język polski to brzmiałoby to:, „Jeżeli zmienna X ma wartość 10 to wyświetl komunikat". Teraz cos trudniejszego:
var
X : Integer;
begin
X := 10;
if X < 50 and X > 5 then // jeżeli X jest mniejsze od 50 i wieksze od 5 to...
if X = 10 then // jeżeli X jest rowne 10 to...
ShowMessage(' Tak, to jest cyfra 10 ');
W tym wypadku instrukcja "if" została zagnieżdżona w innej instrukcji "if". W jednej instrukcji "if" może być zawarta nieograniczona ilość innych instrukcji.
var
X : Integer;
begin
X := 10;
if X <> 100 or X < 100 then // jeżeli X jest rożne od 100 i mniejsze od 100...
if X < 70 and not X = 50 then //... i jeżeli X jest mniejsze od 70 i X nie wynosi 50 to...
if X = 10 then
ShowMessage('Tak to cyfra 10! ');
Można dodać także instrukcje "else", co znaczy " w przeciwnym wypadku". Oto przykładzik:
var
X : Integer;
begin
X := Random(100);
if X = 10 then // jeżeli X jest rowne 10
ShowMessage('Tak to cyfra 10! ') // brak srednika!!!
else // w przeciwnym wypadku...
ShowMessage('To jest cyfra rozna od 10!');
W tym wypadku zmienna X jest wartoscia losowana wśród 100 cyfr. Losowanie spełnia funkcja "Random". Jeżeli wylosowana cyfra jest 10 to wyświetl odpowiednia
Informacja. W przeciwnym wypadku wyświetlana jest inna operacja. Zauważ brak średnika przed funkcja "else".
Jak dotąd po słowie "then" następowała tylko jedna funkcja. Jeżeli po słowie "then" znajduje się więcej linii trzeba dodać słowa "being"..."end": Oto przykład:
var
X : Integer;
begin
X := Random(100);
if X = 10 then
begin
ShowMessage('Tak to jest odpowiednia cyfra! ');
Inc(X);
end else
ShowMessage('To nie ta cyfra!');
Rozumiesz, o co chodzi? Po słowie, „then" mamy dwie funkcje i z tego powodu należy dodać słowa "being" i "end". Można oczywiście nie stosować funkcji "else":
var
X : Integer;
begin
X := Random(100);
if X = 10 then
begin
ShowMessage('Tak to jest odpowiednia cyfra! ');
Inc(X);
end;
Zastanawiacie się pewnie, co robi funkcja "Inc". Otóż podnosi o jeden wartość w nawiasie:
Inc(10) da 11 i znaczy to samo co: X := X + 1;
Istnieje także funkcja "Dec", która zmniejsza wartość zmiennej o jeden:
Dec(10) da cyfrę 9 i znaczy to co: X := X - 1;
Pętle
Pętle są instrukcjami, które wykonywane są do czasu spełnienia warunków ich zakończenia. Brzmi niejasno?:) Najlepiej wyjaśnić to na przykładzie.
1. Umieść komponent Memo na formularzu. Komponent ten to kontrolka edycyjna ( taki mini edytor tekstu ).
2. W Inspektorze Obiektów zmień właściwość "Name" komponentu na "Memo". Kliknij na pozycji "Lines". Po prawej stronie pojawi się mały przycisk z trzykropkiem
( ... ). Naciśnij ten przycisk - otworzy się okno, w którym możesz wpisać tekst, który wyświetlany będzie w komponencie. Usuń cały tekst.
3. Teraz umieść na formularzu przycisk "Button". Kliknij na niego dwukrotnie. W procedurze wpisz taki tekst:
var
I : Integer; // zmienna Integer
begin
for i := 5 downto 0 do // petla
begin
Sleep(500); // czelak pol sekundy
// dodaj tekst do kontrolki Memo
Memo.Lines.Add(
'To zakończenia programu pozostalo: ' + IntToStr(i));
end;
Sleep(1000); // odczekaj sekunde
Close; // zamknij program
Na samym początku ( for i := 5 ) następuje przypisanie wartość do zmiennej "i". Następnie słowo "downto" - zmniejszanie wartości "i". Na samym końcu słowo "do" i
"begin", po czym następują instrukcje, które maja być wykonywane 5 razy. W powyższym przykładzie następuje zmniejszanie zmiennej 5 do 0. Następnie funkcja
"Sleep". Powoduje ona zatrzymanie dalszych działań na okres czasu wpisany w nawisanie. W nawisanie wpisuje się wartość podana w milisekundach ( 1 sekunda =
1000 milisekund ). Następnie następuje wpisanie odpowiednich linii do komponentu Memo. Funkcja "Add" dodaje nowy ciąg znaków w nowej linii. Tekst, który ma być
dodany wpisany musi być w apostrofach. Na końcu znana już funkcja "IntToStr", która konwertuje zmienna Integer, na String. Konwertuje w tym wypadku zmienna "I",
która jest typu "Integer". Następnie następuje koniec wykonywania pętli i odczekanie sekundy poczym następuje zamkniecie programu ( "Close" ).
Powyższa pętla zmniejsza wartość zmiennej ( "downto" ) z 5 do 0. Możliwe jest odliczenie do góry:
for i := 0 to 5 do // petla odlicza od 0 do 5
begin
// wykonywanie dalszych operacji.
Istnieją jeszcze dwa rodzaje pętli, ale omówię je w kolejnym rozdziale. Zapraszam na moja stronę, na której znajdziesz wiele artykułów dotyczących Delphi, FAQ, kody
źródłowe, programy i dużo więcej. Zapraszam: www.programowanie.of.pl |
