Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00583 010372 11031908 na godz. na dobę w sumie
Delphi. Szybki start - książka
Delphi. Szybki start - książka
Autor: Liczba stron: 224
Wydawca: Helion Język publikacji: polski
ISBN: 83-246-0226-7 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> delphi - programowanie
Porównaj ceny (książka, ebook, audiobook).

Język Pascal, kojarzący się głównie z nauką programowania, stał się podstawą jednego z najpopularniejszych obecnie środowisk programistycznych -- Delphi firmy Borland. To graficzne środowisko, pozwalające na szybkie tworzenie aplikacji dzięki możliwości składania ich z 'klocków' zwanych komponentami, błyskawicznie zyskało uznanie programistów na całym świecie. Kolejne wersje Delphi oferowały coraz większe możliwości. Jego najnowsza wersja pozwala na tworzenie programów dla platformy .NET i korzystanie nie tylko z języka Pascal, ale również z coraz popularniejszego C#.

Książka 'Delphi. Szybki start' to doskonały przewodnik po Delphi dla początkujących użytkowników. Dzięki niemu poznasz język Object Pascal i zasady programowania obiektowego. Nauczysz się wykorzystywać komponenty do tworzenia aplikacji i od zera napiszesz własne programy. Dowiesz się, czym się różni Delphi 7 od Delphi 2005, i wykorzystasz możliwości obu tych środowisk.

Poznaj możliwości środowiska Delphi.

Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

IDZ DO IDZ DO PRZYK£ADOWY ROZDZIA£ PRZYK£ADOWY ROZDZIA£ SPIS TREŒCI SPIS TREŒCI KATALOG KSI¥¯EK KATALOG KSI¥¯EK KATALOG ONLINE KATALOG ONLINE ZAMÓW DRUKOWANY KATALOG ZAMÓW DRUKOWANY KATALOG TWÓJ KOSZYK TWÓJ KOSZYK DODAJ DO KOSZYKA DODAJ DO KOSZYKA CENNIK I INFORMACJE CENNIK I INFORMACJE ZAMÓW INFORMACJE ZAMÓW INFORMACJE O NOWOŒCIACH O NOWOŒCIACH ZAMÓW CENNIK ZAMÓW CENNIK CZYTELNIA CZYTELNIA FRAGMENTY KSI¥¯EK ONLINE FRAGMENTY KSI¥¯EK ONLINE Delphi. Szybki start Autor: Maciej Szmit ISBN: 83-246-0226-7 Format: B5, stron: 224 Jêzyk Pascal, kojarz¹cy siê g³ównie z nauk¹ programowania, sta³ siê podstaw¹ jednego z najpopularniejszych obecnie œrodowisk programistycznych — Delphi firmy Borland. To graficzne œrodowisko, pozwalaj¹ce na szybkie tworzenie aplikacji dziêki mo¿liwoœci sk³adania ich z „klocków” zwanych komponentami, b³yskawicznie zyska³o uznanie programistów na ca³ym œwiecie. Kolejne wersje Delphi oferowa³y coraz wiêksze mo¿liwoœci. Jego najnowsza wersja pozwala na tworzenie programów dla platformy .NET i korzystanie nie tylko z jêzyka Pascal, ale równie¿ z coraz popularniejszego C#. Ksi¹¿ka „Delphi. Szybki start” to doskona³y przewodnik po Delphi dla pocz¹tkuj¹cych u¿ytkowników. Dziêki niemu poznasz jêzyk Object Pascal i zasady programowania obiektowego. Nauczysz siê wykorzystywaæ komponenty do tworzenia aplikacji i od zera napiszesz w³asne programy. Dowiesz siê, czym siê ró¿ni Delphi 7 od Delphi 2005, i wykorzystasz mo¿liwoœci obu tych œrodowisk. (cid:129) Interfejs u¿ytkownika œrodowiska Delphi (cid:129) Elementy jêzyka Object Pascal (cid:129) Programowanie obiektowe (cid:129) Obs³uga wyj¹tków (cid:129) Tworzenie okien dialogowych (cid:129) Projektowanie interfejsów u¿ytkownika (cid:129) Korzystanie z komponentów Poznaj mo¿liwoœci œrodowiska Delphi Wydawnictwo Helion ul. Chopina 6 44-100 Gliwice tel. (32)230-98-63 e-mail: helion@helion.pl Spis treści Wprowadzenie 7 Rozdział 1. Zaczynamy 13 Interfejs użytkownika ...............................................................................13 Pierwszy program w Delphi .....................................................................17 Aplikacje konsolowe ................................................................................18 Diagramy składniowe ...............................................................................25 Rozdział 2. Nieobiektowe elementy języka Object Pascal 27 Stałe, identyfikatory i wyrażenia ..............................................................27 Typy danych, zmienne, instrukcja przypisania, rzutowanie typów, funkcje ord, pred i succ ...........................................29 Zmienne z wartością początkową .............................................................37 Operatory ..................................................................................................38 Operacje wejścia-wyjścia, procedury write/writeln i read/readln ............42 Typy łańcuchowe i operator konkatenacji ................................................43 Instrukcja pusta i instrukcja złożona ........................................................44 Instrukcja warunkowa ..............................................................................45 Instrukcja wyboru .....................................................................................49 Definiowanie własnych typów, typy wyliczeniowe i okrojone, zgodność typów, zgodność w sensie przypisania .....................................50 Typ wariantowy ........................................................................................54 Definicja statycznego typu tablicowego ...................................................55 Instrukcja iteracyjna, procedury break i continue ....................................56 Instrukcja iteracyjna z warunkiem na końcu ............................................59 Instrukcja iteracyjna z warunkiem na początku .......................................60 Typ rekordowy (bez wariantów), nazwy kwalifikowane i instrukcja wiążąca ...........................................62 Rekordy z wariantami ..............................................................................66 S p i s t r e ś c i 3 Spis treści Podprogramy — pojęcia podstawowe: funkcje, procedury, zmienne lokalne, parametry formalne i aktualne, dyrektywy języka, parametry o domyślnej wartości, procedury inc i dec ...........................69 Podprogramy — efekty uboczne ..............................................................76 Podprogramy — rekurencja .....................................................................77 Podprogramy — przeciążanie ..................................................................78 Podprogramy — konwencje wywołania i dyrektywa forward .................79 Śledzenie działania programu ..................................................................81 Typ zbiorowy, operator in ........................................................................83 Typy wskaźnikowe i zmienne dynamiczne ..............................................85 Dynamiczny typ tablicowy .......................................................................91 Tablice otwarte i wariantowe tablice otwarte ...........................................92 Moduły i przestrzenie nazw .....................................................................95 Typ plikowy .............................................................................................98 Typ proceduralny ...................................................................................103 Etykiety i instrukcja skoku .....................................................................104 Procedury kierujące działaniem programu: exit, halt, runerror, sleep, abort ............................................................105 Operator @ i funkcja addr ......................................................................106 Rozdział 3. Wprowadzenie do technik obiektowych. Wybrane obiektowe elementy języka Object Pascal 109 Klasy, obiekty, metaklasy, generalizacja ...............................................110 Polimorfizm, metody dynamiczne i wirtualne .......................................115 Abstrakcja ...............................................................................................119 Hermetyzacja ..........................................................................................122 Agregacja ...............................................................................................125 Asocjacja i porozumiewanie się za pomocą komunikatów ....................125 Operatory is i as ......................................................................................126 Interfejsy (typ interface) .........................................................................129 Podstawy obsługi sytuacji wyjątkowych ................................................132 Programowanie z użyciem wątków ........................................................139 Przeciążanie operatorów w Delphi 2005 dla .NET ................................143 i c ś e r t s i p S 4 Spis treści Rozdział 4. Programowanie wizualno-obiektowe 145 Pierwsza aplikacja okienkowa ................................................................145 Implementacja prostych operacji wejścia i wyjścia w programie okienkowym. Komponent TEdit, typ Pchar, modalne i niemodalne okna dialogowe ...............................................154 Tworzenie dodatkowych okien w programie .........................................161 Przetwarzanie komunikatów Windows. Metoda ProcessMessages obiektu Application ....................................163 Dynamiczne tworzenie komponentów ...................................................165 Biblioteki DLL w Windows. Dyrektywa external .................................169 Pakiety ....................................................................................................173 Instalacja i deinstalacja dodatkowych komponentów ............................175 Tworzenie własnych komponentów .......................................................181 Zakończenie Dodatek A Bibliografia Dodatek B Identyczność typów, zgodność i zgodność w sensie przypisania Dodatek C Słowa kluczowe i symbole specjalne Dodatek D Dyrektywy języka w Delphi 2005 Dodatek E Spis rysunków Dodatek F Spis tabel Dodatek G Spis listingów Skorowidz S p i s t r e ś c i 191 193 195 197 199 201 205 207 213 5 Rozdział 2. Nieobiektowe elementy języka Object Pascal Nieobiektowe elementy języka Object Pascal Stałe, identyfikatory i wyrażenia Język Delphi operuje pojęciami wyrażeń i zmiennych w sposób podobny do innych języków programowania. Pojęcie stałej jest używane w znaczeniu matematycznym (na przykład stała e — podstawa logarytmów naturalnych odpowiadająca liczbie równej w przybliżeniu 2,718281828). W programie stała będzie po prostu wartością reprezentowaną przez jakiś symbol (nazwę stałej). Ilekroć w programie (w kodzie źródłowym) wystąpi nazwa stałej, Delphi podstawi w tym miejscu odpowiednią wartość. Nazwa stałej nazywana jest jej identyfikatorem. Oczywiście musisz poinformować Delphi, że pod daną nazwą będzie kryła się jakaś wartość. Sam z siebie program nie będzie wiedział, czy symbol „X” oznacza wartość pięć, czy może osiem. Definicje stałych zapisujemy również w części biernej programu, poprzedzając je słowem const (ang. constant — stała). Wyrażenie jest zbiorem wartości stałych, zmiennych i łączących je operatorów (czyli symboli oznaczających operacje, na przykład operacje dodawania oznaczamy operatorem „+”). W obrębie wyrażeń możesz również używać nawiasów okrągłych. Na przykład wyrażeniem jest 22+432+23–2098 albo 88+(23–23). Do wyświetlania na ekranie wartości wyrażeń, stałych i zmiennych służą w języku Pascal (i w Delphi) wspomniane wcześniej procedury: write, wyświetlająca wyrażenie podane jako parametr, i writeln, która wyświetla wyrażenie podane jako parametr i przesuwa kursor do następnej linii. S t a ł e , i d e n t y f i k a t o r y i w y r a ż e n i a 27 Rozdział 2. Wskazówki n Parametry procedur podajemy w Delphi w nawiasach okrągłych. n Procedura writeln wyświetla obliczoną uprzednio wartość podanego jako parametr wyrażenia. Na listingu 2.1 przedstawiony został przykład programu wykorzystującego procedurę writeln. Na listingu 2.2 przedstawiono program, w którym użyto stałej o nazwie „dwa”, zdefiniowanej w sekcji definicji stałych (linijki 3 i 4). Jak widzisz, do poinformowania programu o wartości stałej użyto znaku równości. Efektem działania programu jest wyświetlenie na ekranie liczby 5, która jest wynikiem obliczenia wartości wyrażenia będącego parametrem wywołania procedury writeln. Wskazówka n Zwróć uwagę, że po słowie kluczowym const nie ma średnika. Podobnie średnika nie używamy po innych słowach kluczowych oznaczających początki sekcji. Możemy w tym miejscu wyjaśnić pojęcie definicji stałej, posługując się poznanymi uprzednio diagramami składniowymi (rysunek 2.1). W definicji stałych możliwe jest dodatkowo użycie niektórych funkcji wbudowanych1, tak aby stała (lub zmienna inicjowana) przyjmowała wartość wyrażenia zbudowanego za ich pomocą, na przykład: {1} const {2} L:longint=trunc(9.3212); {3} M =trunc(9.3212); Można również użyć rzutowania typów (pojęcie to zostanie wyjaśnione w kolejnym podrozdziale). a i n e ż a r y w i y r o t a k i f y t n e d i , e ł a t S Listing 2.1. Program obliczający wartość wyrażenia 2+2 i wyświetlający wynik {1} program Project1; {2} {$APPTYPE CONSOLE} {3} begin {4} writeln(2+2); {5} readln; {6} end. Listing 2.2. Przykład użycia stałej {1} program Project1; {2} {$APPTYPE CONSOLE} {3} Const //tu zaczyna sie sekcja definicji stałych {4} dwa=2; //definicja stalej o nazwie „dwa” rownej 2 {5} begin {6} writeln(dwa+3); {7} readln; {8} end. Rysunek 2.1. Diagram składniowy pojęcia „definicja stałej” (wersja uproszczona) Wskazówka n Pamiętaj: jeśli chcielibyśmy, żeby nasz program wyświetlił na ekranie nie liczbę, a napis (ciąg znaków), powinniśmy jako parametru wywołania procedury writeln użyć tego ciągu ujętego w apostrofy. 1 Funkcje: abs, chr, hi, high, length, lo, low, odd, ord, pred, round, sizeof, succ, swap oraz trunc. Pojęcie funkcji zostanie wyjaśnione w dalszej części książki. 28 Rysunek 2.2. Diagram składniowy pojęcia „deklaracja zmiennych” Nieobiektowe elementy języka Object Pascal Typy danych, zmienne, instrukcja przypisania, rzutowanie typów, funkcje ord, pred i succ Jak zapewne się domyślasz, oprócz stałych bardzo przydałyby się w programie struktury danych, których wartości zmieniałyby się w trakcie działania programu. Takimi strukturami są zmienne. Zmienna to struktura danych o określonej nazwie, służąca do przechowywania wartości określonego typu, która to wartość może zmieniać się w trakcie działania programu. Pojęcie to jest używane podobnie jak pojęcie zmiennej w matematyce. Jeśli mówimy np. o liczbie X, to przez ten symbol rozumiemy jakąś dowolną ustaloną liczbę, na której będziemy przeprowadzać rozmaite operacje. Deklaracje zmiennych zapisujemy w części biernej programu w sekcji deklaracji zmiennych, poprzedzając je słowem var (ang. variables — zmienne). Każda zmienna musi należeć do określonego typu, to znaczy decydując się na użycie w programie zmiennej, musimy zdecydować, czy będzie ona na przykład liczbą (i jakiego rodzaju), czy napisem. W przeciwnym razie wyniki działania naszego programu nie byłyby jednoznacznie określone. Na przykład z połączenia napisów (znaków pisma) „1” i „0” otrzymamy napis „10”, natomiast dodanie liczb 1 i 0 da w wyniku oczywiście jeden. Dlatego też deklaracja zmiennej zawiera określenie typu, do którego zmienna należy, przy czym przez typ danych rozumie się zbiór możliwych wartości wraz z określonym identyfikatorem (rysunek 2.2). T y p y d a n y c h 29 Listing 2.3. Wykorzystanie zmiennej {1} program Project2; {2} {$APPTYPE CONSOLE} {3} var {4} x:integer; {5} begin {6} x:=8; {7} writeln( wartosc zmiennej i{s wynosi: ); {8} writeln(x); {9} readln; {10} end. Rysunek 2.3. Definicja instrukcji przypisania Rozdział 2. W Delphi istnieje rozbudowana hierarchia typów, z których najważniejsze są typy proste (rzeczywiste i porządkowe), strukturalne (tablicowe, rekordowe, zbiorowe, plikowe i obiektowe), wskaźnikowe, wariantowe, proceduralne oraz łańcuchowe. Najprostsze typy, z którymi będziesz się spotykać, to typ znakowy deklarowany słowem char (ang. character — znak pisma), oznaczający pojedynczy znak pisma (literę, cyfrę, znaki przestankowe itd.), typ łańcuchowy string (ang. string — sznurek), używany do zapisu łańcucha znaków, typ całkowitoliczbowy integer (ang. integer — całkowitoliczbowy), używany do zapisu liczb całkowitych (dodatnich i ujemnych) dających się zapisać w dwóch bajtach pamięci (wliczając bit znaku), oraz typ rzeczywisty real (ang. real — rzeczywisty), używany do zapisu liczb posiadających część ułamkową. Wskazówka n Mówimy o sekcji definicji stałych (gdyż tam definiujemy stałe — podajemy zarówno ich identyfikatory, jak i wartości) i o sekcji deklaracji zmiennych (tam bowiem deklarujemy jedynie, że w programie będziemy używać zmiennych o określonych nazwach należących do określonych typów). Do nadania zmiennej określonej wartości służy instrukcja przypisania, zapisywana za pomocą symbolu dwukropka i znaku równości := (na przykład zapis X:=8 czytamy: „niech zmienna X przyjmie wartość osiem”). W przykładzie przedstawionym na listingu 2.3 widzimy zadeklarowaną (linia 4) zmienną całkowitoliczbową o nazwie x, której w części czynnej programu za pomocą instrukcji przypisania (linia 6) przypisujemy wartość osiem, a następnie wyświetlamy tę wartość na ekranie (linia 8). Formalna definicja pojęcia „instrukcja przypisania” przedstawiona jest na rysunku 2.3. 30 h c y n a d y p y T Listing 2.4. Program obliczający objętość kuli o promieniu 2 {1} program Project1; {2} {$APPTYPE CONSOLE} {3} {program oblicza objetosc kuli o promieniu rownym 2} {4} var {5} promien, objetosc:real; {dwie zmienne rzeczywiste} {6} begin {7} promien:=2; {przypisz zmiennej promien wartosc dwa} {8} objetosc:=4*3.14*promien* åpromien*promien/3; {9} writeln( Objetosc {uli o promieniu 2 wynosi ); {10} writeln(objetosc); {11} writeln( Nacisnij ENTER ); {12} readln; {13} end. Nieobiektowe elementy języka Object Pascal W kolejnym przykładzie (listing 2.4) przedstawiono program obliczający objętość kuli o promieniu 2. W sekcji deklaracji zmiennych zadeklarowano dwie zmienne o nazwach promien i objetosc, obie typu real (linia 5). W części czynnej programu (po słowie kluczowym begin) zmiennej promien przypisano wartość 2, natomiast zmiennej objetosc wartość wyrażenia 4 3 ( ×p promien )3 które wyraża wzór na objętość kuli. Ø Do oznaczenia operacji mnożenia służy w Delphi znak gwiazdki *. Ø Podnoszenie do sześcianu w przykładzie 2.4 zrealizowano jako trzykrotne mnożenie przez siebie zmiennej promien, w języku Pascal nie ma bowiem operatora potęgowania. T y p y d a n y c h Otrzymany na ekranie zapis wyniku: 3.34933333333333E+0001 oznacza liczbę 3,34933333 333333 . 110 × W języku Pascal separatorem części ułamkowej jest kropka, natomiast zapis E+0001 znaczy „razy dziesięć do potęgi pierwszej” (jest to tak zwany zapis naukowy, litera E jest skrótem angielskiego słowa exponent, czyli wykładnik). Objętość kuli wynosi zatem około 33,493 (słownie: trzydzieści trzy i czterysta dziewięćdziesiąt trzy tysięczne). 31 Listing 2.5. Przykład błędnego doboru typu zmiennej {1} program Project2; {2} {$APPTYPE CONSOLE} {3} var {4} x:byte; {5} begin {6} x:=255; {7} x:=x+1; {8} writeln( wartosc zmiennej i{s wynosi: ); {9} writeln(X); {10} readln; {11} end. Rozdział 2. Typy liczbowe (to jest typy całkowite oraz rzeczywiste) różnią się od siebie między innymi rozmiarem pamięci przeznaczonej na zapisanie wartości danej zmiennej oraz sposobem jej reprezentacji. Jeżeli zadeklarujesz daną zmienną jako należącą na przykład do typu całkowitego byte, oznaczać to będzie, że na przechowywanie jej wartości w pamięci RAM komputera zarezerwowano jeden bajt (osiem bitów), zatem największą wartością, jaką zmienna będzie mogła przyjąć, jest 255 (dwójkowo 11111111), a najmniejszą — zero. Próba przypisania tej zmiennej większej wartości może prowadzić do nieoczekiwanych rezultatów działania programu, ponieważ wystąpi tzw. błąd nadmiaru stałoprzecinkowego (ang. Static Point Overflow, SPO). Z tego też powodu w trakcie tworzenia programu istotny jest właściwy dobór typów dla każdej zmiennej. Efektem działania programu z listingu 2.5. będzie wyświetlenie liczby zero. Będzie się tak działo dlatego, że reprezentacją liczby typu byte jest po prostu wartość zapisana w kolejnych bitach jednego bajta. Dla liczby 255 jest to osiem jedynek: 1 1 1 1 1 1 1 1 Po zwiększeniu tej wartości o jeden w pamięci zostanie zapisana liczba 256, czyli dwójkowo 10000000, przy czym najbardziej znaczący bit będzie się już znajdował poza zakresem komórki, w której zapisana jest zmienna, i zostanie pominięty: 1 0 0 0 0 0 0 0 0 zatem program, wyświetlając jej wartość, uwzględni jedynie osiem zer i wyświetli wartość zero. h c y n a d y p y T 32 Nieobiektowe elementy języka Object Pascal Nazwy poszczególnych typów liczbowych, rozmiary pamięci i zakresy, jakie mogą przyjmować należące do nich zmienne, przedstawiono w tabelach 2.1 i 2.2. Wskazówka n Pamiętaj, że wynikiem dzielenia dwóch liczb całkowitych jest często liczba niecałkowita. Operacja dzielenia dwóch liczb w Pascalu zwraca zawsze wynik typu rzeczywistego (nawet jeżeli dzielnik mieści się w dzielnej całkowitą ilość razy, to jest jeżeli wynik ilorazu jest całkowity), dlatego też jeżeli chcemy wynik dzielenia przypisać jakiejś zmiennej, to musi być to zmienna typu rzeczywistego. Przez typy porządkowe rozumie się grupę typów, w których określony jest pewien porządek, to jest pomiędzy elementami należącymi do tego typu można określić relacje: większości i następstwa. Istnienie relacji następstwa oznacza, że dla elementu takiego typu można podać jego następnika lub poprzednika. Na przykład jednobajtowa liczba całkowita 2 jest większa od liczby całkowitej 0, jej poprzednikiem jest liczba 1, a następnikiem liczba 3. Tabela 2.1. Typy rzeczywiste Nazwa typu Minimum Maksimum Liczba cyfr znaczących Rozmiar w bajtach Real48 Single Double Extended Comp Currency Real –2,9×1039 –1,5×1045 –5,0×10324 –3,6×104951 –(263)+1 1,7×1038 3,4×1038 1,7×10308 1,1×104932 (263)+1 11 – 12 7 – 8 15 – 16 19 – 20 19 – 20 –922337203685477,5808 922337203685477,5807 19 – 20 –5,0×10324 1,7×10308 15 – 16 6 4 8 10 8 8 8 Tabela 2.2. Typy całkowite Nazwa typu Integer Cardinal Shortint Smallint Longint Int64 Byte Word Longword Minimum –2147483648 0 –128 –32768 –2147483648 –(263) 0 0 0 Maksimum 2147483647 4294967295 127 32767 2147483647 263–1 255 65535 4294967295 Rozmiar w bajtach 32 z bitem znaku 32 bez bitu znaku 8 bez bitu znaku 16 z bitem znaku 32 z bitem znaku 64 z bitem znaku 8 bez bitu znaku 16 bez bitu znaku 32 bez bitu znaku 33 T y p y d a n y c h Listing 2.6. Użycie funkcji ord, pred i succ {1} program Project1; {2} {$APPTYPE CONSOLE} {3} {4} begin {5} writeln(succ( A )); //jaka litera nastepuje po A {6} writeln(pred( C )); //jaka litera poprzedza C {7} writeln(ord(12)); //numer porzadkowy liczby 12 wsrod liczb typu byte {8} readln; {9} end. Rozdział 2. Aby przekonać się, jaki jest numer porządkowy elementu w danym typie (listing 2.6), posługujemy się funkcją ord(element), poprzednika danego elementu zwraca funkcja pred(element), a następnika — succ(element). Typów określających liczby rzeczywiste nie zaliczamy do typów porządkowych, ponieważ — mimo że wśród liczb rzeczywistych można zdefiniować relację większości — nie można podać dokładnie określonego, jednego bezpośredniego następnika ani poprzednika dowolnej liczby rzeczywistej. Typami wyliczeniowymi nazywamy te typy liczbowe, które są jednocześnie typami porządkowymi. W typie znakowym (char) relacja większości określona jest w ten sposób, że kolejne znaki uporządkowane są według ich kodów ASCII, w szczególności cyfry (od zera do dziewięciu) poprzedzają wielkie litery (w kolejności alfabetycznej), a te z kolei małe litery (w kolejności alfabetycznej). Ostatnimi z typów wyliczeniowych są typy logiczne. Używane są do oznaczenia stanów logicznych: prawda (true) oraz fałsz (false). W standardowym Pascalu istnieje jeden typ logiczny deklarowany za pomocą słowa boolean, w Delphi istnieje kilka typów logicznych, które różnią się reprezentacją (liczbą i sposobem rozumienia bitów przeznaczonych do przechowywania w pamięci wartości typu logicznego). Są to typy Boolean, ByteBool, WordBool oraz LongBool. W klasycznym typie Boolean do zapamiętania wartości przeznaczony jest jeden bajt pamięci i obowiązuje relacja False True, przy czym następnikiem False jest True, a True nie ma następnika. W pozostałych typach logicznych następnikiem True jest False, a następnikiem False jest True. Stosowanie typu boolean jest zalecane wszędzie tam, gdzie nie zachodzi konieczność zachowania zgodności z używanymi bibliotekami lub wymogi programu nie nakazują użycia innych typów logicznych. 34 h c y n a d y p y T Nieobiektowe elementy języka Object Pascal W standardzie języka Pascal każda zadeklarowana zmienna ma nieustaloną wartość początkową, dlatego też zanim zostanie do czegokolwiek użyta, powinna mieć przypisaną jakąś wartość (w przeciwnym razie działanie programu może przynieść nieoczekiwane efekty). Często w początkowej części programu programista umieszcza polecenia zainicjowania zmiennych, to jest przypisuje wszystkim zmiennym występującym w programie jakąś wartość początkową (na przykład zero dla zmiennych liczbowych). Delphi standardowo powinno inicjować zadeklarowane zmienne typów prostych: u liczby — liczbą zero, u znaki — znakiem o numerze porządkowym zero, u zmienne typów logicznych — wartością False. W praktyce jednak inicjowanie to nie zawsze działa poprawnie, dlatego też bezpieczniej jest przeprowadzać je w programie samodzielnie. Rysunek 2.4 przedstawia hierarchię typów w Delphi. T y p y d a n y c h Rysunek 2.4. Podstawowa hierarchia typów w Delphi 35 Listing 2.7. Rzutowanie typów — interpretacja liczby jako znaku {1} program Project2; {2} {$APPTYPE CONSOLE} {3} begin {4} writeln(char(65)); {5} readln; {6} end. Listing 2.8. Rzutowanie liczby zero na wartość typu Boolean {1} program Project2; {2} {$APPTYPE CONSOLE} {3} begin {4} writeln(boolean(0)); {5} readln; {6} end. Rozdział 2. Rzutowanie typów jest to wymuszenie na programie interpretacji zawartości danej komórki pamięci jako wartości należącej do określonego typu. Jeśli na przykład w komórce pamięci o długości jednego bajta zapisaliśmy liczbę 65, to jej zawartość będzie w rzeczywistości zapisana w postaci liczby dwójkowej 01000001. Ten sam zapis i ta sama liczba zinterpretowana jako wartość kodu ASCII odpowiada wielkiej literze A. Jeśli zatem wymusimy na programie taką interpretację, to powinien on potraktować tę wartość jako zakodowaną literę A (listing 2.7). Rzutowanie typów można w Pascalu zrealizować poprzez wywołanie nazwy typu z parametrem (podanym w nawiasach) będącym wartością lub zmienną, która ma być zamieniona na zmienną innego typu. Możesz również rzutować np. liczbę zero na wartość typu logicznego boolean, co da w wyniku wartość False. Natomiast w przypadku liczby jeden będzie to wartość logiczna True (listing 2.8). Wskazówki n Decydując się na użycie rzutowania, musisz dokładnie wiedzieć, w jaki sposób dana wartość jest reprezentowana w pamięci, w przeciwnym razie może dojść do niespodziewanych efektów. n Jak wspomniano w poprzednim podrozdziale, dopuszczalne jest użycie rzutowania typów w obrębie sekcji definicji stałych, na przykład prawidłowy będzie zapis Const N=byte(false);. n Oprócz rzutowania typów możesz posłużyć się licznymi dostępnymi w standardowych modułach funkcjami konwersji typów, które zazwyczaj są bezpieczniejsze. h c y n a d y p y T 36 Listing 2.9. Przykład użycia zmiennej inicjowanej {1} program Project2; {2} {$APPTYPE CONSOLE} {3} const {4} dziwna_stala:byte=3; {5} begin {6} writeln(dziwna_stala); {7} dziwna_stala:=15; {8} writeln(dziwna_stala); {9} readln; {10} end. Nieobiektowe elementy języka Object Pascal Zmienne z wartością początkową Jak pamiętasz, stałe nie wymagają deklarowania typów, do których należą. Kompilator, dobierając typ stałej, wybiera typy o możliwie najmniejszej liczebności. Programista może umieścić w definicji stałej jawną deklarację typu (na przykład aby wymusić inną jej reprezentację). Na przykład: const liczba_pi:double=3.14; Tak zdefiniowane stałe, zwane typed constants — stałymi o jawnie zadeklarowanym typie, w rzeczywistości zachowują się jak zmienne (dlatego też nazywa się je czasem zmiennymi inicjowanymi). Możliwe jest modyfikowanie ich wartości wewnątrz części czynnej programu. W kolejnym przykładzie (listing 2.9) w linii 4 w obrębie sekcji definicji stałych zdefiniowano zmienną, której następnie w części czynnej programu (linia 7) przypisano wartość inną niż wartość początkowa. Z m i e n n e z w a r t o ś c i ą p o c z ą t k o w ą 37 Rozdział 2. Operatory Poznałeś już operatory: + (plus), oznaczający dodawanie, oraz * (razy), oznaczający mnożenie. Wszystkie operatory liczbowe przedstawia tabela 2.3. Operator div służy do dzielenia bez reszty. Wynikiem operacji jest wtedy liczba całkowita (typu całkowitego). W takim przypadku zmienna, w której chcemy zapisać wynik, może być zadeklarowana jako zmienna całkowita, jak pokazano w przykładzie (listing 2.10). Tabela 2.3. Operatory arytmetyczne dwuargumentowe w Delphi Operator + (plus) - (minus) * (gwiazdka) / (ukośnik) div mod Operacja Dodawanie Odejmowanie Mnożenie Dzielenie Dzielenie bez reszty Reszta z dzielenia Listing 2.10. Użycie operatora div {1} program Project1; {2} {$APPTYPE CONSOLE} {3} {4} uses {5} SysUtils; {6} {7} var {8} a,b,c:byte; {9} r:real; {10} begin {11} a:=11; {12} b:=5; {13} c:=a div b; {14} r:=a div b; {15} writeln( zapisany w postaci liczby cal{owitej ); {16} writeln( wyni{ dzielenia cal{owitego 11 div 5 wynosi ,c); {17} writeln( a zapisany w postaci liczby rzeczywistej ); {18} writeln( wyni{ tego samego dzielenia wynosi ,r); {19} writeln( Nacisnij ENTER ); {20} readln; {21} end. y r o t a r e p O 38
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Delphi. Szybki start
Autor:

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: