Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
01292 012700 11048775 na godz. na dobę w sumie
Delphi 7 dla każdego - książka
Delphi 7 dla każdego - książka
Autor: , Liczba stron: 832
Wydawca: Helion Język publikacji: polski
ISBN: 83-7361-091-X Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> delphi - programowanie
Porównaj ceny (książka, ebook, audiobook).
Dawno już minęły czasy, gdy podstawowym sposobem tworzenia programów było mozolne 'wklepywanie' kodu. Forma przekazywanej komputerowi i uzyskiwanej za jego pomocą informacji stała się nie mniej ważna od treści. W takim właśnie kontekście zrodziły się narzędzia do błyskawicznego tworzenia aplikacji (RAD), wśród których jednym z najpopularniejszych jest Delphi. Oparte na języku ObjectPascal ma za sobą długą tradycji, ukazała się już 7 edycja tego narzędzia.

To, że Delphi jest wizualnym środowiskiem programistycznym, w którym wiele działań wykonuje się łatwiej niż w tradycyjnych środowiskach opartych na tekście, nie oznacza, że jego użytkownik może obejść się bez podręcznika. Taki podręcznik trzymasz właśnie w ręku. Został on napisany w sposób fachowy i przystępny. Dzięki 'Delphi 7. Dla każdego' poznasz Delphi i nauczysz się pisać w nim programy, nawet jeśli nie jesteś informatykiem.

Książka opisuje:

Dzięki narzędziom takim jak Delphi nawet osoby, które wcześniej nie programowały, mogą pisać złożone aplikacje o atrakcyjnym interfejsie. Przy okazji nauczą się podstaw programowania, a zdobytą w ten sposób wiedzę łatwo przeniosą do innych środowisk i systemów.

Przed instalacją Delphi 7 Personal prosimy zapoznać się z informacjami na stronie producenta. Pozwolą one uzyskać klucz autoryzacyjny i numer seryjny, które są niezbędne do prawidłowego procesu instalacji.

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 Delphi 7 dla ka¿dego 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 Wydawnictwo Helion ul. Chopina 6 44-100 Gliwice tel. (32)230-98-63 e-mail: helion@helion.pl Autorzy: Andrzej Gra¿yñski, Zbigniew Zarzycki ISBN: 83-7361-091-X Format: B5, stron: 830 Zawiera CD-ROM Dawno ju¿ minê³y czasy, gdy podstawowym sposobem tworzenia programów by³o mozolne „wklepywanie” kodu. Forma przekazywanej komputerowi i uzyskiwanej za jego pomoc¹ informacji sta³a siê nie mniej wa¿na od treġci. W takim w³aġnie kontekġcie zrodzi³y siê narzêdzia do b³yskawicznego tworzenia aplikacji (RAD), wġród których jednym z najpopularniejszych jest Delphi. Oparte na jêzyku ObjectPascal ma za sob¹ d³ug¹ tradycji, ukaza³a siê ju¿ 7 edycja tego narzêdzia. To, ¿e Delphi jest wizualnym ġrodowiskiem programistycznym, w którym wiele dzia³añ wykonuje siê ³atwiej ni¿ w tradycyjnych ġrodowiskach opartych na tekġcie, nie oznacza, ¿e jego u¿ytkownik mo¿e obejġæ siê bez podrêcznika. Taki podrêcznik trzymasz w³aġnie w rêku. Zosta³ on napisany w sposób fachowy i przystêpny. Dziêki „Delphi 7. Dla ka¿dego” poznasz Delphi i nauczysz siê pisaæ w nim programy, nawet jeġli nie jesteġ informatykiem. Ksi¹¿ka opisuje: • Typy danych i operatory w Delphi • Instrukcje, tworzenie w³asnych procedur i funkcji • Programowanie zorientowane obiektowo: klasy, metaklasy, interfejsy • Tworzenie bibliotek DLL w Delphi • Ďrodowisko zintegrowane (IDE) Delphi • Tworzenie atrakcyjnego interfejsu u¿ytkownika • Ďledzenie wykonania programu i usuwanie z niego b³êdów • Obs³ugê baz danych w Delphi Dziêki narzêdziom takim jak Delphi nawet osoby, które wczeġniej nie programowa³y, mog¹ pisaæ z³o¿one aplikacje o atrakcyjnym interfejsie. Przy okazji naucz¹ siê podstaw programowania, a zdobyt¹ w ten sposób wiedzê ³atwo przenios¹ do innych ġrodowisk i systemów. Spis treści Rozdział 1. Wprowadzenie .................................................................................... 9 Trochę zabawy...................................................b...................................................b.11 Rozdział 2. Kompendium języka Delphi................................................................ 19 Moduły aplikacji w Delphi...................................................b....................................19 Struktury danych w językach programowania...................................................b.........28 Typy danych w Delphi ...................................................b.........................................29 Typy proste ...................................................b...................................................b30 Typy łańcuchowe...................................................b...........................................37 Typy strukturalne...................................................b...........................................42 Typy wariantowe ...................................................b...........................................75 Typy wskaźnikowe ...................................................b........................................88 Definiowane obsady typów wariantowych...................................................b........98 Deklarowanie typów ...................................................b..........................................162 Reprezentacje danych w kodzie źródłowym ...................................................b.........164 Literały ...................................................b...................................................b....165 Stałe synonimiczne...................................................b.......................................166 Stałe typowane ...................................................b............................................167 Zmienne...................................................b...................................................b...171 Operatory...................................................b...................................................b.......178 Operatory arytmetyczne ...................................................b...............................179 Operatory porównania ...................................................b..................................181 Operatory logiczne (boolowskie)...................................................b...................182 Operatory bitowe ...................................................b.........................................182 Operatory zbiorowe...................................................b......................................188 Operator konkatenacji łańcuchów ...................................................b..................188 Operator referencji ...................................................b.......................................189 Pierwszeństwo operatorów ...................................................b.................................189 Zgodność typów danych...................................................b.....................................191 Identyczność typów ...................................................b.....................................191 Kompatybilność typów...................................................b.................................192 Zgodność typów w sensie przypisania (przypisywalność) ...................................193 Rzutowanie i konwersja typów...................................................b............................195 Instrukcje...................................................b...................................................b.......199 Instrukcje proste ...................................................b..........................................200 Instrukcje strukturalne ...................................................b..................................202 Procedury i funkcje...................................................b............................................215 Przekazywanie parametrów do procedur i funkcji ..............................................219 Parametry amorficzne...................................................b...................................224 4 Delphi 7 dla każdego Tablice otwarte ...................................................b............................................227 Przeciążanie procedur i funkcji...................................................b......................232 Parametry domyślne procedur i funkcji ...................................................b..........236 Zagnieżdżone definicje procedur i funkcji oraz zasięg deklaracji .........................239 Deklaracje zapowiadające (forward) ...................................................b..............240 Typy proceduralne ...................................................b.............................................241 Obiekty, klasy i programowanie zorientowane obiektowo.........................................248 Definiowanie klas ...................................................b........................................250 Tworzenie i unicestwianie zmiennych obiektowych ...........................................260 Zgodność typów obiektowych a polimorfizm..................................................b...263 Przeciążanie metod ...................................................b......................................269 Metaklasy ...................................................b...................................................b......272 Metaklasy a metody wirtualne ...................................................b.......................277 Metaklasy a wirtualne konstruktory ...................................................b...............280 Operatory klasowe ...................................................b.......................................285 Uniwersalne metody metaklasowe ...................................................b.................288 Interfejsy ...................................................b...................................................b.......289 Deklarowanie interfejsów ...................................................b.............................290 Implementowanie interfejsów...................................................b........................291 Deklaracje zapowiadające klas i interfejsów ...................................................b.........302 Pocztówka z przeszłości — obiekty Turbo Pascala...................................................303 Strukturalna obsługa wyjątków ...................................................b...........................304 try...finally, czyli gwarancja ...................................................b..........................305 try...except, czyli naprawa...................................................b.............................310 Wyjątki jako klasy Delphi...................................................b.............................317 Hierarchia obsługi wyjątków i wyjątki nieobsłużone ..........................................324 Generowanie wyjątków ...................................................b................................328 Ponawianie wyjątków...................................................b...................................332 Rozdział 3. Opcje kompilacji i kompilacja warunkowa....................................... 337 Opcje związane z nowościami Delphi ...................................................b..................338 $H ($LONGSTRINGS) — długie łańcuchy...................................................b....338 $REALCOMPATIBILITY — tradycyjny typ zmiennoprzecinkowy .................... 339 $J ($WRITEABLECONST) — stałe czy zmienne? ............................................339 Opcje testowe...................................................b...................................................b.341 $R ($RANGECHECKS) — kontrola zakresu ...................................................b.342 $I ($IOCHECKS) — kontrola poprawności operacji wejścia-wyjścia ..................342 $Q ($OVERFLOWCHECKS) — kontrola nadmiaru stałoprzecinkowego ............342 $C ($ASSERTIONS) — honorowanie albo ignorowanie asercji ..........................343 Tradycyjne opcje pascalowe ...................................................b...............................343 $X ($EXTENDEDSYNTAX) — rozszerzona składnia.......................................344 $V ($VARSTRINGCHECKS) — kontrola zgodności parametrów łańcuchowych... 344 $P ($OPENSTRINGS) — domyślne łańcuchy otwarte .......................................346 Opcje interpretacyjne ...................................................b.........................................346 $B ($BOOLEVAL) — obliczanie wyrażeń boolowskich ....................................346 $T ($TYPEDADDRESS) — kontrola referencji ................................................348 Opcje generacyjne ...................................................b.............................................349 $O ($OPTIMIZATION) — optymalizowanie generowanego kodu......................349 $W ($STACKFRAMES) — generowanie ramek stosu.......................................349 $A ($ALIGN) — wyrównywanie pól rekordów i klas.........................................350 $Z ($MINENUMSIZE) — minimalny rozmiar zmiennej typu wyliczeniowego ....350 $U ($SAFEDIVIDE)...................................................b....................................351 Opcje sterujące informacją dodatkową...................................................b.................351 $D ($DEBUGINFO) — generowanie informacji dla debuggera ..........................352 $L ($LOCALSYMBOLS) — generowanie informacji o symbolach lokalnych .....352 Spis treści 5 $Y ($REFERENCEINFO i $DEFINITIONINFO) — generowanie informacji o symbolach i odwołaniach do nich.........................352 $M ($TYPEINFO) — generowanie informacji RTTI .........................................353 Opcje związane z komunikatami kompilatora...................................................b.......353 $HINTS...................................................b...................................................b...353 $WARNINGS ...................................................b.............................................353 $WARN...................................................b...................................................b...354 Dyrektywa $MESSAGE...................................................b...............................355 Opcje parametryczne ...................................................b.........................................355 $M ($MINSTACKSIZE, $MAXSTACKSIZE) — ustalenie wielkości stosu dla programu...................................................b....355 $IMAGEBASE — bazowy obszar ładowania biblioteki DLL..............................356 $APPTYPE — typ aplikacji ...................................................b..........................357 $D ($DESCRIPTION) — opis aplikacji ...................................................b.........357 $E ($EXTENSION) — rozszerzenie generowanego pliku wykonywalnego..........357 Opcje integracyjne ...................................................b.............................................357 $I ($INCLUDE) — dołączanie fragmentów kodu źródłowego.............................357 $L ($LINK) — dołączanie skompilowanych modułów .......................................363 $R ($RESOURCE) — dołączanie plików zasobowych.......................................363 Kompilacja warunkowa...................................................b......................................363 Symbole kompilacji warunkowej...................................................b...................364 Wyrażenia kompilacji warunkowej ...................................................b................374 Opcje kompilacji i kompilacja warunkowa aktualność modułów wynikowych............377 Rozdział 4. Biblioteki DLL ................................................................................. 379 Biblioteki DLL a środowisko zintegrowane Delphi ..................................................380 Tworzenie bibliotek DLL w Delphi ...................................................b.....................382 Klauzule resident, export i local...................................................b.....................389 Statyczne łączenie bibliotek DLL...................................................b........................393 Moduły importowe bibliotek DLL...................................................b.................397 Dynamiczne łączenie bibliotek DLL...................................................b....................403 Procedura inicjująco-kończąca biblioteki DLL ...................................................b.....406 Bazowy adres ładowania biblioteki DLL...................................................b..............409 Klasy i obiekty w bibliotekach DLL ...................................................b....................411 Importowanie obiektu na podstawie deklaracji klasy ..........................................411 Implementowanie interfejsów przez obiekt znajdujący się w bibliotece DLL........419 Rozdział 5. Środowisko zintegrowane Delphi 7 ................................................. 429 Projekty w środowisku IDE...................................................b................................430 Domyślne opcje projektu...................................................b..............................436 Opcje menu głównego i paski narzędzi ...................................................b................448 Formularze i paleta komponentów...................................................b.......................449 Podstawowe właściwości i zdarzenia formularzy ...................................................b..450 Modalne i niemodalne wyświetlanie formularza.................................................461 Ważniejsze metody formularzy ...................................................b.....................470 Wielokrotne wykorzystywanie formularzy za pośrednictwem repozytorium.........473 Siatka formularza ...................................................b.........................................477 Zaznaczanie komponentów ...................................................b...........................478 Przesuwanie komponentów...................................................b...........................482 Zmiana rozmiarów komponentów...................................................b..................483 Skalowanie położenia i rozmiarów komponentów za pomocą okna dialogowego skalowania ...................................................b....484 Wyrównywanie i dopasowywanie położenia komponentów ................................ 485 Właściwości komponentów odpowiedzialne za ich rozmiary i ułożenie................488 6 Delphi 7 dla każdego Ochrona położenia i rozmiarów komponentów ..................................................491 Wycinanie, kopiowanie i wklejanie komponentów .............................................491 Warstwowy układ komponentów...................................................b...................493 Cykl Tab...................................................b...................................................b..494 Inspektor obiektów ...................................................b............................................495 System menu aplikacji i projektant menu ...................................................b.............498 Zachowywanie układu pulpitu...................................................b.............................518 Edytor kodu Delphi...................................................b............................................520 Otwieranie i zapisywanie plików ...................................................b...................521 Praca z blokami tekstu...................................................b..................................522 Cofanie i ponawianie poleceń (Undo) ...................................................b............527 Wyszukiwanie i zamiana fragmentów tekstu...................................................b...527 Szablony kodu ...................................................b.............................................531 Uzupełnianie i parametryzowanie kodu...................................................b..........533 Podpowiedzi kontekstowe związane z elementami kodu.....................................535 Uzupełnianie klas...................................................b.........................................536 Nawigowanie po implementacji klasy ...................................................b............538 „Parowanie” nawiasów...................................................b.................................538 Menu kontekstowe edytora kodu...................................................b...................538 Diagramy powiązań...................................................b......................................538 Konfigurowanie edytora kodu...................................................b.......................541 Eksplorator kodu ...................................................b...............................................549 Ustawienia związane z eksploratorem kodu...................................................b....550 Przeglądarka projektu...................................................b.........................................551 Rozdział 6. Śledzenie programu......................................................................... 553 Przygotowanie aplikacji do śledzenia zintegrowanego..............................................554 Elementy śledzenia zintegrowanego ...................................................b....................554 Praca krokowa...................................................b.............................................554 Punkty przerwań...................................................b..........................................557 Podgląd wyrażeń i modyfikowanie zmiennych programu....................................563 Inspektor śledzenia...................................................b.............................................569 Śledzenie kodu biblioteki DLL...................................................b............................571 Dziennik zdarzeń ...................................................b...............................................572 Ustawienia związane ze zintegrowanym debuggerem...............................................573 Strona General...................................................b.............................................573 Strona Event Log ...................................................b.........................................574 Strona Language Exceptions ...................................................b.........................574 Strona OS Exceptions...................................................b...................................575 Turbo Debugger — TD32.EXE ...................................................b..........................576 Rozdział 7. Komponenty Delphi......................................................................... 579 Zdarzenia komponentów ...................................................b....................................581 Hierarchia komponentów...................................................b....................................587 Komponenty wizualne ...................................................b..................................589 Właściwości komponentów oraz ich obsługa za pomocą inspektora obiektów ............594 Właściwości proste ...................................................b......................................594 Właściwości wyliczeniowe ...................................................b...........................594 Właściwości zbiorowe ...................................................b..................................594 Właściwości obiektowe ...................................................b................................595 Właściwości tablicowe ...................................................b.................................596 Strumieniowanie komponentów i domyślna wartość właściwości ........................598 Współdzielenie metod dostępowych — właściwości indeksowane.......................603 Spis treści 7 Przegląd komponentów ...................................................b......................................605 Etykiety — TLabel i TStaticText..................................................b....................606 Komponenty edycyjne — TEdit, TMaskEdit, TMemo i TRichEdit...................... 607 Przyciski ...................................................b...................................................b..616 Komponenty selekcyjne — TListBox, TListCheckBox i TComboBox .................627 Komponent zegarowy — TTimer ...................................................b..................631 Komponenty standardowych okien dialogowych................................................632 Tworzenie nowego komponentu...................................................b..........................644 Rozdział 8. Technologia COM ........................................................................... 655 Rozdział 9. Obsługa baz danych w Delphi .......................................................... 667 Wstęp...................................................b...................................................b............667 Lokalne bazy danych...................................................b....................................669 Bazy danych typu klient-serwer...................................................b.....................669 Wielowarstwowa architektura baz danych...................................................b......670 Przegląd technologii...................................................b...........................................671 ClientDataSet ...................................................b..............................................672 Borland Database Engine (BDE) ...................................................b...................672 InterBase Express ...................................................b........................................673 dbExpress...................................................b...................................................b.674 DbGo (ADOExpress) ...................................................b...................................674 DataSnap ...................................................b...................................................b.675 Wybór technologii dostępu do danych ...................................................b.................675 Podejście prototypowe ...................................................b.................................675 Planowanie „cyklu życiowego” ...................................................b.....................676 Połączenie z bazami danych w środowisku Delphi .............................................676 Tworzenie prostego formularza bazy danych...................................................b..678 Dodawanie kolejnych kontrolek bazodanowych.................................................682 Relacja ogół-szczegóły ...................................................b.................................685 Obsługa pól rekordów ...................................................b........................................687 Właściwości pól i komponent TField ...................................................b.............687 Edytor właściwości pól...................................................b.................................689 Modyfikowanie właściwości pola ...................................................b..................691 Formatowanie pól przy użyciu masek edycyjnych..............................................692 Dostęp do wartości kolumny...................................................b.........................694 Pola wyliczane...................................................b.............................................696 Pola przeglądowe ...................................................b.........................................698 Weryfikacja danych wejściowych...................................................b..................700 Zbiory danych ...................................................b...................................................b702 Kontrolowanie wskaźnika bieżącego rekordu ...................................................b.704 Edycja danych...................................................b.............................................706 Ograniczanie zbiorów danych ...................................................b.......................707 Wyszukiwanie rekordów ...................................................b..............................709 Oznaczanie rekordów za pomocą zakładek...................................................b.....711 Definiowanie wartości domyślnych pól ...................................................b..........712 Podstawowe właściwości, metody i zdarzenia zbiorów danych............................713 Współpraca z serwerami...................................................b.....................................713 Autoryzacja klienta ...................................................b......................................715 Transakcje ...................................................b..................................................719 Komponent ClientDataSet ...................................................b..................................721 Borland Database Engine...................................................b....................................729 Administrator BDE ...................................................b......................................729 Instalacja BDE...................................................b.............................................736 8 Delphi 7 dla każdego Kreator formularzy baz danych ...................................................b.....................736 Komponenty BDE ...................................................b.......................................741 Funkcje BDE API...................................................b........................................751 ActiveX Database Objects ...................................................b..................................753 ADO w Delphi...................................................b.............................................754 Standardowe sterowniki ADO ...................................................b.......................757 Argumenty połączenia ...................................................b..................................757 TADOConnetion...................................................b..........................................759 TADODataSet...................................................b.............................................761 Excel jako baza danych ...................................................b................................762 Dostęp do danych za pomocą technologii dbExpress ................................................766 Komponenty interfejsu dbExpress ...................................................b.................767 Jak to działa w praktyce? ...................................................b..............................768 Uzgadnianie błędów serwera...................................................b.........................771 Rozpowszechnianie aplikacji z interfejsem dbExpress ........................................772 InterBase Express ...................................................b..............................................774 Przegląd komponentów InterBase Express ...................................................b.....775 Technologia DataSnap ...................................................b.......................................780 Architektura wielowarstwowa ...................................................b.......................781 MIDAS i DataSnap...................................................b......................................783 Podsumowanie ............................................................................... 791 Skorowidz....................................................................................... 793 Typy danych w Delphi Ile wagonów potrzeba do przewiezienia 14 obrabiarek, jeżeli w jednym wagonie mieszczą się cztery obrabiarki? Wynikająca z prostego dzielenia odpowiedź — 3,5 — jest w oczywisty sposób bezsensowna, nie można bowiem podzielić wagonu na pół (na upartego można, lecz wtedy nie będzie nadawał się do przewiezienia czegokolwiek). Jaka jest różnica między liczbami 6,30 a 2,45 — jaki jest odstęp czasowy między godziną 6:30 a 2:45? Argumenty odejmowania niby te same, lecz wyniki różne (3,85 i 3:45). Te banalne przykłady pokazują, iż w wielu obliczeniach musimy ograniczyć się tylko do pewnej kategorii danych (tu liczb całkowitych), a sposób wykonywania podstawo- wych działań często zależy od charakteru danych (inaczej odejmuje się ułamki dzie- siętne, inaczej wskazania zegara). Gdy przyjrzeć się operacjom wykonywanym przez współczesne procesory, można zauważyć podobną tendencję: zupełnie różne reguły rządzą podstawowymi operacjami matematycznymi wykonywanymi na liczbach całkowitych, liczbach zmiennoprzecin- kowych i liczbach dziesiętnych, mimo kodowania ich w tej samej postaci — wzorców bitowych. Ta cecha koncepcyjna (i konstrukcyjna) komputerów zaważyła w głównej mierze na konstrukcji samych języków programowania: okazało się mianowicie, że tworzenie języków programowania będzie łatwiejsze (same zaś języki — bardziej efektywne), jeżeli również na ich gruncie odzwierciedlone zostanie owo zróżnicowanie danych. I tak zostało do dziś, choć gwoli sprawiedliwości wspomnieć należy o dwóch istotnych faktach. Otóż po pierwsze, już w latach sześćdziesiątych twórcy języka Algol 60 zamierzali stworzyć język umożliwiający posługiwanie się liczbami bez koniecz- ności ich różnicowania (choć z możliwością różnicowania na żądanie), lecz w sytu- acji, gdy pamięć typowego komputera miała pojemność co najwyżej kilku tysięcy słów, tak ambitne zamierzenia musiały pozostać w sferze marzeń. Po drugie nato- miast — rozwijające się techniki wymiany danych i oprogramowania pomiędzy kom- puterami doprowadziły do sytuacji, w której w pewnych zastosowaniach opisanego różnicowania utrzymać się nie da, wymianie podlega bowiem informacja o wysoce zróżnicowanym charakterze. Na potrzeby obsługi tego typu informacji wprowadzono do języków programowania tzw. zmienne wariantowe, którymi zajmiemy się w dal- szym ciągu rozdziału. Zbiór wartości o określonym charakterze i zdefiniowanych działaniach nazywamy w języku programowania typem danych. Język Delphi ma wiele typów predefiniowa- nych, z których programista może korzystać bez ich deklarowania. Użytkownik ma jednak nieograniczoną praktycznie możliwość definiowania własnych typów, stosow- nie do charakteru rzeczywistych danych, odzwierciedlanych (w założeniu możliwie jak najwierniej) w tworzonym programie. Nie jest niczym niezwykłym fakt, iż reper- tuar tych typów jest nieporównywalnie bogatszy w porównaniu do „gołego” kompu- tera — na tym w końcu polega rola języków wysokiego poziomu. Hierarchiczne zestawienie typów dostępnych w Delphi przedstawiamy na rysunku 2.1. Ograniczony zakres niniejszej książki nie pozwala na ich wyczerpujące omówie- nie, skoncentrujemy się więc na ich najważniejszych cechach. 30 Delphi 7 dla każdego Rysunek 2.1. Zestawienie typów Delphi Typy proste Wielkość typu prostego (zwanego również typem skalarnym) zawiera pojedynczą wartość. Wielkością skalarną jest więc liczba całkowita, liczba rzeczywista, numer miesiąca czy nawet odpowiedź tak-nie na kategorycznie sformułowane pytanie; nie należą do wielkości skalarnych liczby zespolone (dwie wartości), wektory, macierze, ciągi itp. Pascal nie zalicza również do typów skalarnych napisów, ponieważ każdy z nich rozpatrywany może być jako ciąg wielu znaków. Typ skalarny może mieć własność przeliczalności — określenie to oznacza, że wszyst- kie jego wartości można ustawić w ciąg, a dla każdej wartości istnieje ściśle określo- ny następnik i poprzednik (jednak z zastrzeżeniem skończoności — patrz niżej). W naturze własność tę mają np. liczby całkowite. Nie są przeliczalne liczby rzeczywi- ste — przeprowadzenie dowodu tego faktu (tzw. metodą przekątniową Cantora) jest przedmiotem elementarnego kursu arytmetyki i wykracza poza ramy niniejszej książ- ki. Typ skalarny posiadający własność przeliczalności nazywamy typem porządko- wym (ordinal type). Języki programowania ze zrozumiałych względów stanowią jedynie przybliżony opis świata rzeczywistego. Jednym z aspektów owego przybliżenia jest skończoność — i tak, na przykład, każdy typ całkowitoliczbowy posiada wartość najmniejszą i naj- większą, a liczby zmiennoprzecinkowe mogą być reprezentowane jedynie ze skoń- czoną dokładnością. Jako że wartości typów zmiennoprzecinkowych reprezentowane są przy wykorzystaniu skończonej liczby bitów, liczba możliwych do zapisania war- tości jest skończona i można by pokusić się o sztuczne wprowadzanie przeliczalności tych typów; posunięcie takie byłoby jednak ściśle związane z konkretną architekturą komputera i raczej mało przydatne. Z tego względu typy zmiennoprzecinkowe nie są w Pascalu zaliczane do typów porządkowych. 30 (03-05-16) C:AndrzejPDFDelphi 7 dla każdego29-37.doc Rozdział 2. ♦ Kompendium języka Delphi 31 Typy porządkowe Każdy typ porządkowy reprezentuje w Pascalu skończony, jednoznacznie uporząd- kowany 1 zbiór wartości. Dla każdego typu porządkowego można określić wartość naj- mniejszą i największą, zaś dla każdej jego wartości można określić wartość następną i poprzednią (z oczywistym ograniczeniem w odniesieniu do wartości najmniejszej i największej). W Delphi rozróżnia się pięć rodzajów typów porządkowych:  całkowitoliczbowe — reprezentujące określone przedziały liczb całkowitych,  znakowe — reprezentujące zestawy znaków z określonych alfabetów,  logiczne (boolowskie) — reprezentujące wartości prawda i fałsz w określonych reprezentacjach,  wyliczeniowe — reprezentujące podane explicite zbiory wartości definiowane przez użytkownika,  okrojone — stanowiące określone przedziały innych typów porządkowych. Dla każdego typu porządkowego określone są następujące funkcje:   .QY — zwraca najmniejszą wartość reprezentowaną przez dany typ, *KIJ — zwraca największą wartość reprezentowaną przez dany typ. Dla każdej wartości typu porządkowego dodatkowo określone są następujące funkcje:    1TF — zwraca numer kolejny wartości w ramach wartości reprezentowanych przez dany typ 2; najmniejsza reprezentowana wartość ma numer 0, 2TGF — zwraca poprzednią wartość w ramach typu (nie dotyczy najmniejszej wielkości reprezentowanej przez dany typ), 5WEE — zwraca następną wartość w ramach typu (nie dotyczy największej wielkości reprezentowanej przez dany typ). Dla wygody operowania danymi typów porządkowych zdefiniowano również w Pas- calu dwie następujące procedury:   +PE — zwiększa (inkrementuje) wartość argumentu (+PE : równoważne jest :5WEE : ), GE — zmniejsza (dekrementuje) wartość argumentu ( GE : równoważne jest :2TGF : ). ó 1 2 Słowo jednoznacznie jest tu istotne; w przeciwieństwie bowiem do skończonego zbioru, np. ułamków zwykłych, który to zbiór uporządkować można według różnych kryteriów, każdy typ porządkowy posiada jedno i tylko jedno uporządkowanie. Funkcja 1TF nie ma zastosowania do typu +PV z prostego powodu: rodzimą arytmetyką Delphi jest arytmetyka 32-bitowa i wartość zwracana przez funkcję 1TF musi zmieścić się na 32 bitach. Typ +PV — jako reprezentowany na 64 bitach — jest więc pewnym wyjątkiem wśród typów porządkowych. C:AndrzejPDFDelphi 7 dla każdego29-37.doc (03-05-16) 31 32 Delphi 7 dla każdego Typy całkowitoliczbowe Typ całkowitoliczbowy reprezentuje (zgodnie z nazwą) przedział liczb całkowitych. Ze- staw typów całkowitoliczbowych zdefiniowanych w Delphi przedstawiamy w tabeli 2.1. Tabela 2.1. Typy całkowitoliczbowe Delphi Zakres Reprezentacja maszynowa słowo (32 bity) ze znakiem słowo (32 bity) bez znaku bajt (8 bitów) ze znakiem bajt (8 bitów) bez znaku półsłowo (16 bitów) ze znakiem półsłowo (16 bitów) bez znaku słowo (32 bity) ze znakiem słowo (32 bity) bez znaku dwusłowo (64 bity) ze znakiem Typ +PVGIGT CTFKPCN 5JQTVKPV $[VG Ō  Ō  5OCNNKPV Ō 9QTF .QPIKPV .QPIYQTF +PV  Ō  ŌŌ Zwróć uwagę, że typy 32-bitowe (zarówno ze znakiem, jak i bez) posiadają podwójną reprezentację. Wynika to z przyjętej w Delphi filozofii, zgodnie z którą typy +PVGIGT i CTFKPCN zawsze cechują się najbardziej optymalną implementacją dla danej wersji Delphi i z tej racji określane są mianem typów rodzimych (generic); ich reprezentacja zależna jest od konkretnej wersji Delphi. Pozostałe typy całkowitoliczbowe, określane mianem typów fundamentalnych, mają reprezentację uniwersalną3, która w przy- szłych wersjach Delphi pozostanie niezmieniona. Należy zachować pewną ostrożność w operowaniu danymi typu +PV. Przekracza on granice domyślnej dla Delphi, 32-bitowej arytmetyki, co ma swe konsekwencje, mię- dzy innymi, w stosunku do niektórych funkcji i procedur, obcinających argumenty do 32 bitów. Ograniczenie to nie dotyczy jednak funkcji (procedur) standardowych (po- dajemy za dokumentacją Delphi 7) *KIJ, .QY, 5WEE, 2TGF, +PE, GE, +PV6Q5VT i +PV6Q*GZ. Ponadto w sytuacji, gdy wyniki pośrednie obliczeń na liczbach całkowitych przekra- czają granice 32 bitów, końcowe wyniki mogą być niepoprawne. W poniższym przy- kładzie: KL.QPIKPV M+PV  K L MK L ó 3 Pewnym wyłomem w tej uniwersalności jest typ CTFKPCN, który w Delphi 3 ograniczony był do nieujemnej połówki typu .QPIKPV   Począwszy od Delphi 4 jest on pełnoprawną 32-bitową liczbą bez znaku. 32 (03-05-16) C:AndrzejPDFDelphi 7 dla każdego29-37.doc Rozdział 2. ♦ Kompendium języka Delphi 33 wartością zmiennej M po wykonaniu obliczeń jest nie , jak można by ocze- kiwać, lecz Ō — wszystko wskutek obcięcia do 32 bitów. By uniknąć tej niespodzianki, należałoby wymusić (na kompilatorze) użycie arytmetyki 64-bitowej, na przykład przez rzutowanie jednego z argumentów dodawania na typ +PV: M+PV K  L Możesz się o tym przekonać, uruchamiając projekt #TKVJ znajdujący się na dołą- czonym do książki CD-ROM-ie. Typy logiczne (boolowskie) Wielkość typu boolowskiego reprezentuje jedną z wartości prawda albo fałsz, ozna- czonych stałymi symbolicznymi (odpowiednio) 647 i (#.5 . W Delphi istnieją cztery typy boolowskie (patrz tabela 2.2): Tabela 2.2. Typy boolowskie boolowskie Delphi Typ Wielkość Reprezentacja wartości FALSE Reprezentacja wartości TRUE $QQNGCP $[VG$QQN 9QTF$QQN .QPI$QQN bajt (8 bitów) bajt (8 bitów) półsłowo (16 bitów) słowo (32 bity)      dowolna wartość niezerowa dowolna wartość niezerowa dowolna wartość niezerowa Typ $QQNGCP jest rodzimym typem pascalowym i jako taki zalecany jest do wykorzy- stywania w tworzonych aplikacjach. Pozostałe typy boolowskie istnieją przez zgod- ność z innymi językami (m.in. Visual Basiciem) i bibliotekami oprogramowania. Zwróć uwagę, iż typ $QQNGCP cechuje się pewną niedookreślonością: reprezentacją (#.5 jest , reprezentacją 647 jest . A co z pozostałymi wartościami, od  do ? Jeżeli : jest zmienną typu $QQNGCP, warunek: KH : ŗ jest równoważny warunkowi: KH 1TF :   czyli wspomniany przedział zaliczany jest do reprezentacji wartości 647 . Jednakże już porównanie: KH :647 interpretowane jest dosłownie, czyli równoważne jest porównaniu: KH 1TF :  a więc wspomniany przedział zaliczany jest na poczet reprezentacji wartości (#.5 . C:AndrzejPDFDelphi 7 dla każdego29-37.doc (03-05-16) 33 34 Delphi 7 dla każdego Typy $[VG$QQN, 9QTF$QQN i .QPI$QQN wolne są od tej niekonsekwencji — w odniesie- niu do nich porównania: KH :647 oraz: KH : są równoważne. Jeżeli chodzi o skrajne wartości typów boolowskich, sprawa przedstawia się dosyć ciekawie (tabela 2.3): Tabela 2.3. Zakres typów boolowskich Typ $QQNGCP $[VG$QQN 9QTF$QQN .QPI$QQN Ord(Low(typ)) Ord(High(typ))       Ō  Zatem dla typu .QPI$QQN (i tylko dla niego) możliwa jest sytuacja, w której spełnione są jednocześnie trzy warunki: :(#.5 , ;647 i 1TF : 1TF ; — wówczas (w pew- nym sensie) (#.5 647 . O prawdziwości powyższych wywodów możesz się o tym przekonać, uruchamiając projekt $QQN5RGE znajdujący się na dołączonym do książki CD-ROM-ie. Typy wyliczeniowe Typ wyliczeniowy (enumerated type) stanowi reprezentację zdefiniowanego ad hoc zbioru elementów posiadających wspólną pewną cechę; poszczególne elementy identy- fikowane są przez unikalne nazwy nie mające poza tym żadnego innego znaczenia merytorycznego. Oto przykłady typów wyliczeniowych: UVCPQMPC 65VCP1MPC 0QTOCNPG OKPKOCNKQYCPG OCMU[OCNKQYCPG  UVTQP[ħYKCVC 6-KGTWPGM YUEJQFRQNWFPKGCEJQFRQNPQE  MQNQT[MCTEKCPG 6-QNQT-CTV[ VTGHNMCTQMKGTRKM Każda z wartości typu wyliczeniowego jest stałą tegoż typu — zgodnie z powyższymi definicjami nazwa MCTQ jest stałą typu 6-QNQT-CTV[. Funkcja 1TF zastosowana do elementu typu wyliczeniowego zwraca numer kolejny tego elementu w definicji typu począwszy od zera — tak więc 1TF VTGHN   , 1TF CEJQF    itd. Funkcje .QY i *KIJ zwracają (odpowiednio) pierwszy i ostatni element w definicji typu. A zatem, na przykład, .QY 65VCP1MPC 0QTOCNPG, a *KIJ 6-QNQT-CTV[ RKM. 34 (03-05-16) C:AndrzejPDFDelphi 7 dla każdego29-37.doc Rozdział 2. ♦ Kompendium języka Delphi 35 Począwszy od Delphi 6, można w sposób jawny przypisywać poszczególnym ele- mentom (wszystkim lub tylko niektórym) wartość, którą ma dla nich zwrócić funkcja 1TF. Oto przykład: 61FRQYKGF 0KGŌ0KG9KGO6CM  Funkcje .QY i *KIJ zwracają wówczas te elementy, którym przypisano (odpowiednio) najmniejszą i największą wartość. Elementy, którym nie przypisano wartości w sposób jawny, otrzymują kolejne warto- ści większe od poprzedników. Jeżeli nie przypisano wartości pierwszemu elementowi, otrzymuje on wartość . Zgodnie z poniższą definicją: 62CTVKCN PWO PQ0KUMQ2QKQO-TQM9[GL)QTC5E[V zachodzą następujące równości: 1TF PQ  1TF 0KUMQ  1TF 2QKQO  1TF -TQM  1TF 9[GL  1TF )QTC  1TF 5E[V  Typy znakowe Wielkość typu znakowego reprezentuje pojedynczy znak alfabetyczny. Aktualnie w Delphi zdefiniowane są dwa fundamentalne typy znakowe:   #PUK JCT — reprezentuje zbiór znaków określony normą ANSI, poszerzony jednak o specyficzne znaki narodowe dla poszczególnych wersji. Wartość tego typu zajmuje jeden bajt, a więc liczba reprezentowanych znaków nie przekracza 256. 9KFG JCT — reprezentuje znaki wielobajtowe. Aktualnie zmienna typu 9KFG JCT zajmuje dwa bajty, sam zaś typ odpowiada zbiorowi znaków UNICODE. Pierwsze 256 wartości typu 9KFG JCT są identyczne z typem #PUK JCT. Rodzimym typem znakowym Pascala jest typ JCT, w dotychczasowych wersjach Delphi równoważny typowi #PUK JCT (sytuacja ta może się zmienić w przyszłych wersjach). Typy okrojone Typ okrojony (subrange type) stanowi ciągły podzbiór innego typu porządkowego zwanego typem bazowym. Oto przykłady definicji typów okrojonych: 6.KVGT[ #  V[RDCQY[Ō JCT 6 [HT[V[RDCQY[Ō+PVGIGT 6$TCM6CM0KG0KG9KGOV[RDCQY[Ō61FRQYKGF Typy okrojone dziedziczą z typu bazowego wartości funkcji 1TF dla swych elementów, co skądinąd jest całkiem zrozumiałe — 1TF # równe jest  niezależnie od tego, czy znak # postrzegamy jako wartość typu JCT czy też typu 6.KVGT[. C:AndrzejPDFDelphi 7 dla każdego29-37.doc (03-05-16) 35 36 Delphi 7 dla każdego Typy zmiennoprzecinkowe Typy zmiennoprzecinkowe (floating point types) reprezentują podzbiory liczb rze- czywistych ze zróżnicowaną dokładnością. Delphi definiuje 6 fundamentalnych typów zmiennoprzecinkowych zgodnych z normą ANSI/IEEE 754. Ich charakterystyka przed- stawiona jest w tabeli 2.4. Tabela 2.4. Fundamentalne typy zmiennoprzecinkowe Delphi Typ Zakres Liczba dziesiętnych cyfr znaczących Dokładność (liczba bitów mantysy) Rozmiar 5KPING QWDNG ZVGPFGF QOR ×Ō×(moduł) ×Ō×(moduł) ×Ō×(moduł) Ō Ō Ō Ō Ō Ō WTTGPE[ Ō Ō 4GCN ×Ō× Ō       4 bajty 8 bajtów 10 bajtów 8 bajtów 8 bajtów 6 bajtów QOR jest w tym zestawieniu o tyle nietypowy, iż został on zaliczony do zmiennoprze- cinkowych jedynie ze względów historycznych — w Turbo Pascalu wszystko, co miało związek z koprocesorem, zaliczane było do arytmetyki zmiennoprzecinkowej. Pod względem fizycznym wartość typu QOR jest ośmiobajtową liczbą całkowitą ze znakiem, o czym można się przekonać, wykonując poniższą sekwencję: 8CT   ZVGPFGF   QOR          Po zakończeniu zmienna zawiera wartość , a nie . Mimo takiego zachowania typ QOR nie może być traktowany na równi z liczbami całkowitymi — przede wszystkim dlatego, że nie jest typem porządkowym. Wraz z pojawieniem się (w Delphi 4) typu +PV typ QOR stracił praktycznie swoje znaczenie i zachowany został tylko ze wzglę- dów zachowania kompatybilności. Typ WTTGPE[ używany jest głównie do reprezentowania danych finansowych (stąd nazwa). Mimo iż zaliczono go do typów zmiennoprzecinkowych, jest on tak naprawdę liczbą stałoprzecinkową o ustalonej (równej ) liczbie miejsc dziesiętnych. Podobnie jak typ QOR, jest on reprezentowany w postaci 64-bitowej liczby całkowitej ze zna- kiem, przy czym zapisywana wartość jest 10 000 razy większa od wartości faktycznie reprezentowanej (stąd właśnie cztery miejsca po przecinku). 36 (03-05-16) C:AndrzejPDFDelphi 7 dla każdego29-37.doc Rozdział 2. ♦ Kompendium języka Delphi 37 Typ 4GCN to dziedzictwo wczesnych wersji Turbo Pascala, w których był jedynym typem używanym do obliczeń zmiennoprzecinkowych (nosił wówczas nazwę 4GCN). Zajmuje 6 bajtów (= 48 bitów, stąd nazwa 4GCN), format jego reprezentacji binarnej jest całkowicie odmienny od pozostałych typów, zaś wszelkie operacje z jego udzia- łem odbywają się wyłącznie w sposób programowy, bez jakiegokolwiek wsparcia sprzętowego, co decyduje o niskiej efektywności obliczeń. Został zachowany jedynie ze względów kompatybilności wstecz. Rodzimy typ zmiennoprzecinkowy Delphi nosi nazwę 4GCN. Jeszcze w Delphi 3 był on równoważny temu, co dzisiaj kryje się pod nazwą 4GCN. Począwszy od Delphi 4 stał się on równoważny typowi QWDNG, zaś spadkowy typ 4GCN przechrzczony został na 4GCN. W przypadku uzasadnionej nostalgii można przywrócić typowi 4GCN dawne znaczenie, używając dyrektywy kompilacji ]4 #. 1/2#6+$+.+6;10_. Oprócz konkretnych wartości liczbowych w ramach typów zmiennoprzecinkowych (z wyjątkiem typu Real48) przechowywać można wartości oznaczające brak konkret- nej liczby (tzw. nieliczby — ang. 0C0 = Not A Number) jak również symbol oznacza- jący nieskończoność. Szczegóły dotyczące wewnętrznej reprezentacji typów zmien- noprzecinkowych dostępne są w systemie pomocy Delphi 7 pod hasłem Real types. Jak widać z tabeli 2.4, największą dokładność obliczeń zapewnia typ ZVGPFGF — jest to dokładność, z jaką przechowywane są przez procesor pośrednie wyniki wy- konywanych przez niego obliczeń. Niektóre programy mogą jednak sztucznie „ob- niżyć” tę domyślną dokładność, głównie ze względów zgodności ze starszymi sys- temami obliczeń zmiennoprzecinkowych. I tak na przykład niektóre procedury Win32 API przełączają procesor w tryb dokładności 53-bitowej, charakterystycznej dla typu QWDNG. Z tego względu zalecanym typem dla obliczeń zmiennoprzecinko- wych w aplikacjach Win32 jest typ QWDNG — i nieprzypadkowo to on właśnie jest rodzimym typem zmiennoprzecinkowym, kryjącym się pod synonimem 4GCN. C:AndrzejPDFDelphi 7 dla każdego29-37.doc (03-05-16) 37
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Delphi 7 dla każdego
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ą: