Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00150 009695 11027694 na godz. na dobę w sumie
Kylix. Czarna księga - książka
Kylix. Czarna księga - książka
Autor: , , Liczba stron: 328
Wydawca: Helion Język publikacji: polski
ISBN: 83-7197-565-1 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> systemy operacyjne >> linux
Porównaj ceny (książka, ebook, audiobook).
Poznaj praktyczne przyklady programowania Linuksa z użyciem Kyliksa.

Kylix, pierwsze narzędzie typu RAD (Rapid Application Development) dla systemu operacyjnego Linux jest środowiskiem projektowym dla programowania aplikacji graficznego interfesju użytkownika (GUI), aplikacji WWW oraz baz danych. Napisana przez doświadczonych programistów, ta książka jest po prostu obowiązkową pozycją dla każdego programisty Kyliksa.

Kylix Power Solutions ma dwa główne cele: jak najszybciej zapoznać cię z programowaniem Linuksa oraz dostarczyć gotowych, sprawdzonych rozwiązań najczęściej występujących programistycznych problemów. Przedstawione przykłady obejmują szeroki zakres zagadnień, od kontrolowania KDE po wzajemną komunikację między procesami. Każdy przyklad obejmuje szczegółowe omówienie zagadnienie i zawiera kod źrodlowy programu wykorzystującego omawianą strategię.

Ta książka pomoże Ci w:

Co znajdziesz w tej książce dla siebie:

Ta książka powstała dla:

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

Darmowy fragment publikacji:

IDZ DO IDZ DO PRZYK£ADOWY ROZDZIA£ PRZYK£ADOWY ROZDZIA£ SPIS TRE(cid:140)CI SPIS TRE(cid:140)CI KATALOG KSI¥flEK KATALOG KSI¥flEK KATALOG ONLINE KATALOG ONLINE ZAM(cid:211)W DRUKOWANY KATALOG ZAM(cid:211)W DRUKOWANY KATALOG TW(cid:211)J KOSZYK TW(cid:211)J KOSZYK DODAJ DO KOSZYKA DODAJ DO KOSZYKA CENNIK I INFORMACJE CENNIK I INFORMACJE ZAM(cid:211)W INFORMACJE ZAM(cid:211)W INFORMACJE O NOWO(cid:140)CIACH O NOWO(cid:140)CIACH ZAM(cid:211)W CENNIK ZAM(cid:211)W CENNIK CZYTELNIA CZYTELNIA FRAGMENTY KSI¥flEK ONLINE FRAGMENTY KSI¥flEK ONLINE Wydawnictwo Helion ul. Chopina 6 44-100 Gliwice tel. (32)230-98-63 e-mail: helion@helion.pl Kylix. Czarna ksiŒga Autorzy: Don Taylor, Jim Mischel, Tim Gentry T‡umaczenie: Marcin Pancewicz ISBN: 83-7197-565-1 Tytu‡ orygina‡u: Format: B5, stron: 328 Kylix Power Solutions Kylix, pierwsze narzŒdzie typu RAD (Rapid Application Development) dla systemu operacyjnego Linuks jest (cid:156)rodowiskiem projektowym dla programowania aplikacji graficznego interfesju u¿ytkownika (GUI), aplikacji WWW oraz baz danych. Napisana przez do(cid:156)wiadczonych programist(cid:243)w, ta ksi„¿ka jest po prostu obowi„zkow„ pozycj„ dla ka¿dego programisty Kyliksa. Kylix Power Solutions ma dwa g‡(cid:243)wne cele: jak najszybciej zapozna(cid:230) ciŒ z(cid:160) programowaniem Linuksa oraz dostarczy(cid:230) gotowych, sprawdzonych rozwi„zaæ najczŒ(cid:156)ciej wystŒpuj„cych programistycznych problem(cid:243)w. Przedstawione przyk‡ady obejmuj„ szeroki zakres zagadnieæ, od kontrolowania KDE po wzajemn„ komunikacjŒ miŒdzy procesami. Ka¿dy przyklad obejmuje szczeg(cid:243)‡owe om(cid:243)wienie zagadnienie i(cid:160) zawiera kod (cid:159)rodlowy programu wykorzystuj„cego omawian„ strategiŒ. Ta ksi„¿ka pomo¿e Ci w: Jak najlepszym wykorzystaniu Kyliksa, bezpo(cid:156)rednio po wyjŒciu z opakowania. Poznaniu zasadniczych r(cid:243)¿nic pomiŒdzy programowaniem w Linuksie i(cid:160) w(cid:160) Windows (cid:160) i to w rekordowo kr(cid:243)tkim czasie. Uruchamianiu, kontrolowaniu, zamykaniu i komunikowaniu siŒ z innymi aplikacjami z wnŒtrza swoich program(cid:243)w. Programowym ustawianiu i modyfikowaniu systemowych uprawnieæ Linuksa. Monitorowaniu proces(cid:243)w w systemie. U¿yciu systemowego programu cron do uk‡adania harmonogram(cid:243)w zadaæ administracyjnych. Implementowaniu wsp(cid:243)lnych bibliotek obiekt(cid:243)w. Tworzenie modu‡(cid:243)w interfejsu Pascala dla istniej„cych bibliotek jŒzyka C. Tworzeniu w‡asnego systemu pomocy -- w‡„cznie z w‡asn„ przegl„dark„. Rozwi„zywaniu codziennych programistycznych problem(cid:243)w w Kyliksie. Co znajdziesz w tej ksi„¿ce dla siebie: Przegl„d systemu operacyjnego Linux, w por(cid:243)wnaniu z Windows. Wprowadzenie do jŒzyka C dla programist(cid:243)w Pascala. Przyk‡ady rozwi„zaæ r(cid:243)¿norodnych programistycznych problem(cid:243)w Linuksa i Kyliksa, wraz z om(cid:243)wieniami i przyk‡adami kodu. Ta ksi„¿ka powsta‡a dla: Programist(cid:243)w Delphi przenosz„cych siŒ do Kyliksa. Programist(cid:243)w Visual Basica chc„cych przenie(cid:156)(cid:230) swoje programy do Linuksa. Obecnych programist(cid:243)w Linuksa chc„cych tworzy(cid:230) aplikacje graficznego interfejsu Spis treści O Autorach ...................................................h...................................................h...11 Wprowadzenie ...................................................h..................................................13 Część I Z Delphi do Kyliksa ...................................................e............... 17 Rozdział 1. Porównanie środowisk ...................................................h.....................19 Różnice pomiędzy środowiskami...................................................o..........................................19 Różnice systemowe ...................................................y...................................................y........... 20 Różnice występujące w środowisku programowania ...................................................y................ 22 Open Source ...................................................y...................................................y..................... 23 .......24 System X Window ...................................................y...................................................y............ 24 Menedżer okien.....................................y...................................................y............................... 25 Okna w Linuksie....................................o...................................................o......................... Gdzie znaleźć więcej informacji ...................................................o...........................................27 Rozdział 2. Krótki wykład na temat Linuksa ...................................................h.......29 Pliki i katalogi...................................................o...................................................o......... ...........29 Nazwy plików i katalogów..............................y...................................................y....................... 30 Łącza do plików ...................................................y...................................................y................ 32 Własność plików i katalogów ...................................................y.................................................33 Do czego służą te katalogi?...................................................y.................................................... 35 Techniki programowania Linuksa ...................................................o.........................................36 Koncepcja wywołań systemowych...................................................y......................................... 37 Procesy i sygnały...................................y...................................................y............................... 38 Programowanie wątków...................................................y...................................................y.....39 Komunikacja pomiędzy procesami ...................................................y......................................... 40 System plików /proc ...................................................o...................................................o..........43 Gdzie znaleźć więcej informacji ...................................................o...........................................44 Rozdział 3. Korzystanie z bibliotek ...................................................h.....................45 Tworzenie obiektu wspólnego i korzystanie z niego ...................................................o.............46 Tworzenie grupy projektów...........................y...................................................y........................46 Biblioteka Hello...................................................y...................................................y................. 47 Wywoływanie funkcji bibliotecznych...................................................y...................................... 48 Udostępnianie bibliotek ...................................................y...................................................y...... 49 Konwencje wspólnych bibliotek ...................................................o...........................................50 Konwencje nazywania bibliotek ...................................................y............................................. 50 Gdzie umieścić biblioteki? ...................................................y..................................................... 52 Gdzie Linux szuka bibliotek? ...................................................y................................................. 52 Kylix a zgodność z konwencją bibliotek...................................................y.................................. 53 Zabawa z nazwami funkcji ...................................................y...................................................y.54 C:AndrzejPDFKylix. Czarna księga!Spis-08.doc 5 6 Kylix. Czarna księga Dynamiczne ładowanie bibliotek ...................................................o..........................................55 Inicjalizacja i końcowe działania bibliotek ...................................................y............................... 58 Gdzie szuka bibliotek funkcja dlopen...................................................y...................................... 58 Przenoszenie bibliotek pomiędzy platformami ...................................................o......................58 Konwencje wywołań ...................................................y...................................................y......... 59 Nazwa biblioteki...................................................y...................................................y................ 59 Typ uchwytu biblioteki ...................................................y...................................................y...... 60 Moduł ShareMem.......................................y...................................................y.......................... 60 Kod startowy biblioteki ...................................................y...................................................y...... 60 Moduł interfejsu dla różnych platform ...................................................y.................................... 61 Gdzie znaleźć więcej informacji ...................................................o...........................................63 Rozdział 4. Podstawy C dla programistów Kyliksa .................................................65 Podręcznik C dla programisty Pascala ...................................................o..................................66 Typy danych C i Pascala...............................y...................................................y........................ 66 Zmienne, struktury, unie oraz typy...................................................y......................................... 68 Operatory języka C ...................................................y...................................................y........... 70 Instrukcje sterujące i pętle ...................................................y..................................................... 73 Wskaźniki ...................................................y...................................................y........................ 75 Funkcje i „procedury”................................y...................................................y........................... 78 Pozostałe zagadnienia ...................................................y...................................................y........ 79 Elementy C++...................................................y...................................................y................... 81 Używanie bibliotek C w Kyliksie ...................................................o.........................................83 Tworzenie programów za pomocą polecenia make ...................................................y.................. 84 Tworzenie modułu interfejsu ...................................................y.................................................86 Gdzie znaleźć więcej informacji ...................................................o...........................................92 Część II Przykłady programowania Kyliksa............................................... 95 Rozdział 5. Kontrolowanie procesów ...................................................h..................97 5.1 Zastępowanie bieżącego procesu nowym programem...................................................o.....98 Przykład: program execTest ...................................................y................................................ 100 5.2 Uruchamianie procesu potomnego...................................................o.................................104 Przykład: tworzenie procesu potomnego z programu konsolowego............................................. 105 Przykład: tworzenie procesu potomnego w aplikacji graficznego interfejsu użytkownika .............. 106 5.3 Uruchamianie programu i czekanie na zakończenie jego działania...................................107 Przykład: program forkWait ...................................................y................................................ 107 5.4 Tworzenie procesu działającego w tle...................................................o..........................109 Przykład: program bgTest ...................................................y...................................................y 109 ..110 5.5 Niszczenie procesu...............................o...................................................o....................... Przykład: program CrashTestDummy...................................................y................................... 110 Przykład: moduł ProcStuff ...................................................y.................................................. 112 Przykład: program KillerApp ...................................................y............................................... 116 5.6 Ustalanie priorytetów procesów ...................................................o...................................118 Przykład: program priTest ...................................................y...................................................y120 5.7 Zmniejszanie obciążenia systemu ...................................................o..................................121 Przykład: program Sleeper.............................y...................................................y......................122 5.8 Uzyskiwanie informacji na temat identyfikatora procesu oraz użytkownika .....................124 Przykład: program GetPID ...................................................y.................................................. 125 5.9 Uzyskiwanie szczegółowych informacji na temat procesu ...............................................127 Przykład: wyliczanie procesów ...................................................y............................................ 128 Przykład: uzyskiwanie linii polecenia procesu ...................................................y........................ 129 6 C:AndrzejPDFKylix. Czarna księga!Spis-08.doc Spis trelci 7 Przykład: uzyskiwanie środowiska procesu ...................................................y........................... 131 Przykład: uzyskiwanie pliku wykonywalnego, katalogu główneygo oraz katalogu roboczego procesu ...................................................y....................................... 131 Przykład: uzyskiwanie informacji na temat plików otwartych przez proces ................................. 132 Przykład: uzyskiwanie szczegółowych informacji na temat procesu............................................ 134 5.10 Ograniczanie działania procesu do pojedynczej instancji ..............................................136 Przykład: program OneInst...................................................y.................................................. 137 5.11 Ustalanie harmonogramu działania procesu ...................................................o................140 Przykład: skrypt startdummy ...................................................y............................................... 141 Przykład: program RunAt...................................................y...................................................y. 141 Przykład: program RunScheduled ...................................................y........................................ 144 5.12 Uruchamianie procesu przez superużytkownika ...................................................o..........149 Rozdział 6. Obsługa komunikacji między procesami .............................................151 6.1 Podstawowa komunikacja przeprowadzana z użyciem sygnałów.....................................152 Przykład: program SigSender...................................................y............................................... 154 6.2 Uzyskiwanie opisów poprawnych sygnałów systemowych..............................................157 Przykład: program SigNames...................................................y............................................... 157 6.3 Tworzenie procedur obsługi sygnałów ...................................................o.........................158 Przykład: program HndSender ...................................................y............................................. 158 Funkcja sigaction oraz obiekt TSigAction...................................................y.............................. 159 Zarządzanie zestawami sygnałów ...................................................y......................................... 161 Przykład: program HndRecvr ...................................................y.............................................. 162 6.4 Zabezpieczanie przed procesami zombie ...................................................o......................165 Przykład: program KillAllZombies...................................................y........................................ 165 6.5 Komunikacja z aplikacjami konsoli poprzez potoki ...................................................o......168 Przykład: program PipeRead ...................................................y............................................... 169 Przykład: program RunAt (jeszcze raz)...................................................y................................. 171 6.6 Przekazywanie danych pomiędzy potomnym a nadrzędnym procesem GUI......................172 Przykład: PipeParent ...................................................y...................................................y....... 173 Przykład: PipeChild ...................................................y...................................................y......... 176 6.7 Przekazywanie danych pomiędzy niezależnymi procesami GUI .......................................178 Przykład: FIFOSender ...................................................y...................................................y.....179 Przykład: FIFORecvr...................................................y...................................................y....... 181 6.8 Koordynowanie procesów za pomocą semaforów...................................................o........183 Praca z obiektami IPC ...................................................y...................................................y..... 184 Semafory ...................................................y...................................................y...................... 185 Funkcje semaforów ...................................................y...................................................y......... 185 Tworzenie i otwieranie zestawów semaforów...................................................y........................ 186 Kontrolowanie semaforów za pomocą funkcji semctl...................................................y............. 187 Przykład: program OneAtATime...................................................y.......................................... 192 6.9 Wysoko wydajna komunikacja przeprowadzona z użyciem pamięci wspólnej ................195 Funkcje pamięci wspólnej ...................................................y...................................................y 195 Tworzenie i otwieranie obiektów pamięci wspólnej...................................................y................ 196 Kontrolowanie obiektów pamięci wspólnej..................................................y............................. 197 Przykład: program shmTalk...................................................y................................................. 198 6.10 Komunikowanie się poprzez kolejki komunikatów ...................................................o.....202 Funkcje kolejek komunikatów ...................................................y............................................. 202 Tworzenie i otwieranie kolejek komunikatów...................................................y........................ 203 Kontrolowanie kolejek komunikatów...................................................y.................................... 203 Wysyłanie komunikatów ...................................................y...................................................y.. 205 Odbieranie komunikatów...................................................y...................................................y.. 206 C:AndrzejPDFKylix. Czarna księga!Spis-08.doc 7 8 Kylix. Czarna księga Praca z różnymi rodzajami komunikatów ...................................................y............................. 207 Kolejki komunikatów i wskaźniki...................................................y......................................... 209 Przykład: prosty dziennik debugowania ...................................................y................................ 209 Rozdział 7. Korzystanie z systemu plików ...................................................h.........213 7.1 Sprawdzanie uprawnień dla pliku ...................................................o.................................213 Przykład: program GetPermissions...................................................y....................................... 214 7.2 Definiowanie uprawnień dla pliku ...................................................o................................216 Przykład: program SetPermissions ...................................................y....................................... 216 7.3 Implementacja blokowania plików danych na poziomie plików ......................................218 Przykład: program LockFile...................................................y................................................. 219 7.4 Implementacja blokowania plików danych na poziomie rekordów..................................222 Polecenia blokowania pliku............................y...................................................y......................222 Przypadek hipotetyczny ...................................................y...................................................y...224 Przykład: program LockWriter...................................................y............................................. 224 Przykład: program LockReader...................................................y............................................ 228 7.5 Uzyskiwanie atrybutów i informacji na temat pliku...................................................o.......234 Przykład: program FileInfo ...................................................y..................................................236 7.6 Montowanie innych systemów plików ...................................................o..........................239 Przykład: program MountTool...................................................y............................................. 242 Rozdział 8. Pomoc online ...................................................h.................................247 Architektura systemu pomocy...................................................o..............................................247 8.1 Tworzenie prostej przeglądarki pomocy ...................................................o.......................248 Przykład: klasa TSimpleHelpViewer...................................................y..................................... 250 8.2 Dodawanie pomocy do aplikacji...................................................o...................................255 Przykład: dodawanie pomocy do aplikacji...................................................y............................. 257 8.3 Współpraca z zewnętrznym systemem pomocy ...................................................o.............258 Formularze SimpleHelp...................................................y...................................................y....259 Format plików pomocy ...................................................y...................................................y.... 259 Przykład: implementowanie systemu pomocy SimpleHelp ...................................................y...... 260 Przyszłość pomocy w Kyliksie...................................................y............................................. 267 Rozdział 9. Szuflada................................................h............................................269 9.1 Uzyskiwanie listy zalogowanych użytkowników ...................................................o...........270 Przykład: program LogUser...................................................y................................................. 272 9.2 Sprawdzanie nie odczytanej poczty...................................................o...............................274 Przykład: program CheckMail...................................................y.............................................. 275 9.3 Wysyłanie poczty pod adresy lokalne ...................................................o...........................283 Przykład: program PipeMail ...................................................y................................................ 284 9.4 Użycie programu sendmail z aplikacji...................................................o...........................287 Wysyłanie za pomocą programu sendmail...................................................y............................. 287 Przykład: program FileMail..............................y...................................................y....................288 9.5 Posługiwanie się ósemkowymi maskami uprawnień ...................................................o.....292 Przykład: program OctalConv...................................................y.............................................. 292 9.6 Uruchamianie programu jako superużytkownik (ponownie).............................................296 Dziedziczenie i środowisko...................................................y..................................................297 Przykład: zmiana konfiguracji użytkownika...................................................y........................... 299 Przykład: skrypt runsu1 ...................................................y...................................................y... 299 Przykład: skrypt runsu2 ...................................................y...................................................y... 300 9.7 Wykorzystanie dzienników systemowych do debugowania..............................................301 Systemowe procedury dzienników ...................................................y....................................... 302 8 C:AndrzejPDFKylix. Czarna księga!Spis-08.doc Ukryty demon...................................................y...................................................y................. 303 Przykład: program SysLog ...................................................y.................................................. 305 Skorowidz ...................................................h...................................................h...309 Spis trelci 9 C:AndrzejPDFKylix. Czarna księga!Spis-08.doc 9 Rozdział 4. Podstawy C dla programistów Kyliksa Kluczowe zagadnienia: (cid:1) Podręcznik C dla programisty Pascala (cid:1) Typy danych C i Pascala (cid:1) Zmienne, struktury, unie oraz typy (cid:1) Operatory języka C (cid:1) Instrukcje sterujące i pętle (cid:1) Wskaźniki (cid:1) Funkcje i procedury (cid:1) Elementy C++ (cid:1) Wykorzystywanie bibliotek C w Kyliksie (cid:1) Gdzie znaleźć więcej informacji Jak wspominaliśmy w rozdziale 2., Pascal nigdy nie był dla Linuksa głównym językiem programowania. Ogromna większość bibliotek została napisana w C lub C++ i posiada in- terfejsy oraz przykładowy kod stworzone dla tych właśnie języków. Istnieje bardzo niewiele bibliotek stworzonych w Pascalu, a te, które powstały, są tak zależne od kompilatora, dla którego zostały napisane, że najprawdopodobniej nie będą nadawały się do użycia w Kyliksie. Oznacza to, że ty, jako programista Kyliksa, musisz podjąć decyzję. Jeśli nie chcesz czekać, aż ktoś inny napisze potrzebne ci moduły, możesz albo przepisać same bi- blioteki, albo stworzyć dla nich biblioteki pośrednie, budując własny interfejs API. Jeśli wy- bierzesz pierwsze rozwiązanie, spotkamy się za kilka lat, gdy skończysz projekt. Gdy wy- bierzesz drugie rozwiązanie, będziesz zadowolony, ponieważ Kylix znacznie upraszcza tworzenie modułów interfejsów umożliwiających aplikacjom dostęp do bibliotek języka C. Zauważ, że użyliśmy zwrotu „znacznie upraszcza”, co niekoniecznie oznacza, że jest to łatwe. W pewnych przypadkach nie jest to nawet możliwe, szczególnie, jeśli biblioteki zostały napisane w C++ (z wykorzystaniem specyficznych właściwości tego języka). Mamy jednak powody sądzić, że z czasem ilość bibliotek zgodnych z Kyliksem będzie rosła i mamy szczerą nadzieję, że wkrótce ten rozdział stanie się niepotrzebny. C:AndrzejPDFKylix. Czarna księga4-08.doc 65 66 Czlć I KKKK Z Delphi do Kyliksa Teraz jednak może się okazać, że będziesz musiał czytać przykłady kodu napisanego w C — co stanowi ekscytujące wyzwanie dla programisty Pascala. Język C jest znacz- nie bardziej zagmatwany niż Pascal i z tego powodu czasem może przypominać szyfr. Ogólne zrozumienie niektórych struktur tego języka pomoże Ci jednak w zrozumieniu dokumentacji interfejsów API i przykładów kodu stworzonych dla tego języka. W tym rozdziale zaprezentujemy kluczowe informacje potrzebne do zrozumienia inter- fejsów i przykładów kodu, a także zademonstrujemy, w jaki sposób możesz stworzyć moduły interfejsów Pascala dla bibliotek C. Nie martw się — nie będziemy próbowali zrobić z Ciebie programisty C. Jeśli znasz już ten język, możesz przejść bezpośrednio do podrozdziału „Wykorzystywanie bibliotek C w Kyliksie.” Podrcznik C dla programisty Pascala Zagadnienia programowania w C przedstawimy od początku, wskazując te konstrukcje programowe i właściwości języka, które są unikalne dla C. Wskażemy również podobne właściwości obu języków i zaakcentujemy dzielące je różnice. Zaczniemy od typów danych. Typy danych C i Pascala Podstawowe typy danych w C można podzielić na trzy kategorie — typy całkowite, typy rzeczywiste oraz typy „inne” — zebrano je w tabeli 4.1. Typ języka C, 321 321, nie jest obsługiwany przez wszystkie kompilatory i czasami ma swoją specjalną nazwę (na przykład ))28 w kompilatorach Microsoftu i Borlanda). Choć występuje bardzo rzadko, wspominamy o nim dla dopełnienia obrazu całości. Tabela 4.1. Porównywalne całkowite typy danych Typ C -+6 7368 28 Typ Pascala Opis Zakres #36828 #36828 28/1/6lub 32128 8-bitowa liczba całkowita ze znakiem –128..127 16-bitowa liczba całkowita ze znakiem –32 768..32 767 32-bitowa liczba całkowita ze znakiem –2 147 483 648 .. 2 147 483 647 321 32128 32-bitowa liczba całkowita ze znakiem –2 147 483 648 .. 321321 28 64-bitowa liczba całkowita ze znakiem –9 223 372 036 854 775 808 .. 2 147 483 647 9 223 372 036 854 775 807 92712/.-+6 92712/.7368 8/ 36. 92712/.28 +6.2+ lub 321 36. 92712/.321 321 36. 8-bitowa liczba całkowita bez znaku 0..255 16-bitowa liczba całkowita bez znaku 0..65535 32-bitowa liczba całkowita bez znaku 0..4 294 967 295 32-bitowa liczba całkowita bez znaku 0..4 294 967 295 92712/.321 321 Brak 64-bitowa liczba całkowita bez znaku 0..18 446 744 073 709 551 615 66 C:AndrzejPDFKylix. Czarna księga4-08.doc Rozdział 4. KKKK Podstawy C dla programistów Kyliksa 67 Tak jak w przypadku wszystkich typów w C, wskaźniki można tworzyć dla każdego z ty- pów całkowitych. Omówimy je nieco później. W przeszłości pojawiał się poważny problem z typami rzeczywistymi (czyli zmiennoprzecinkowymi), ponieważ ich implementacja zmieniała się zależnie od kompilatora. Oznaczało to, że typy 03+8 i .39,/ nie były przenaszalne, zwłaszcza pomiędzy różnymi językami. Obecnie jednak większość kom- pilatorów przestrzega standardu IEEE (dla wymagań pojedynczej i podwójnej precyzji), co znacznie zwiększa przenoszalność tych typów. Ale nawet mimo tego, jeśli twoja aplikacja korzysta z tych typów odwołując się do bibliotek C, pamiętaj, aby dokładnie sprawdzić wyniki (patrz tabela 4.2). Tabela 4.2. Porównywalne rzeczywiste typy danych Typ Pascala Opis Zakres Liczba zmiennoprzecinkowa o pojedynczej precyzji Liczba zmiennoprzecinkowa o podwójnej precyzji Liczba zmiennoprzecinkowa o „potrójnej” precyzji W przybliżeniu od 3.4E–38 do 3.4E+38 W przybliżeniu od 1.7E–308 do 1.7E+308 Różny Typ C 03+8 #21/ .39,/ 39,/ 321.39,/ 8/2./. Typy wyliczeniowe (/29) są używane w C do tworzenia zmiennych typu całkowitego, mogących przyjmować z określonego zestawu wartości symbolicznych jedną wartość (patrz tabela 4.3). Tabela 4.3. Porównywalne „inne” typy danych Typ C /29 (Każdy typ całkowity) -+6(cid:31) :3.(cid:31) Typ Pascala Opis Typ wyliczeniowy 33/+2 -+6 lub (+6 Wskaźnik Lista wyliczeniowa określonych wartości całkowitych, wyrażana jako typ. Wartość boolowska (prawda lub fałsz) Wskaźnik do wartości typu +6. Wskaźnik bez typu. Krótka historia typu int Czytelnicy znajcy C mog zauwaryć w tabeli 4.1 nieobecnolć 16-bitowej wersji typu 28. Dawniej rozmiar typu danych 28 zalerał od stosowanego kompilatora C i pierwotnie odpowiadał rozmiarowi komputera, dla którego był kompilowany program. Obecnie typ 28 ma prawie zawsze rozmiar 32 bitów, ale nie jest to zagwarantowane. Gdy pojawi si nowe architektury komputerów i nowe kompilatory, typ 28 z pewnolci stanie si typem 64-bitowym. Ta zmiennolć powoduje, re 28 jest mało popularny w deklaracjach interfejsów API, wic nie natrafia si na niego zbyt czsto. Jelli tak si jednak stanie, powinienel dowiedzieć si z innych pródeł, jaki powinien mieć rozmiar. Typ 28 more sprawiać kłopoty szczególnie wtedy, gdy korzystasz ze starszych bibliotek, na przykład przenoszc kod ze starych, 16-bitowych programów Windows. W takim przypadku musisz zwrócić uwag na wymagania programowego interfejsu API i upewnić si, czy urywasz w swoim kodzie typu całkowitego o odpowiednim rozmiarze. C:AndrzejPDFKylix. Czarna księga4-08.doc 67 68 Czlć I KKKK Z Delphi do Kyliksa Wartości te są wyliczane w deklaracji typu enum, jak pokazano w poniższym przykładzie: /29$/78#8+8974/2.21’ )4+77/.)0+/. Utworzono tu nowy typ o nazwie $/78#8+897. Zmiennym tego typu można przypisywać jedną z trzech wymienionych na liście wyliczenia wartości, tak jak w: $/78#8+897874/2.21 Tworzymy zmienną 87 typu $/78#8+897 i ustawiamy jej wartość jako stałą symboliczną 4/2.21. Jest to bardzo podobne (choć nie zamienne) do typu wyliczeniowego w Pas- calu; zbliżonym odpowiednikiem powyższej deklaracji w Pascalu mogłoby być: 84/ $/78#8+897,4/2.21)4+77/.)0+/.- Wersja w języku C działa nieco inaczej, gdyż wartości stałych symbolicznych na liście mogą być określone albo nieokreślone — są wtedy numerowane kolejno począwszy od zera. Z perspektywy Pascala poprzednia deklaracja C tworzy zmienną o rozmiarze typu 28 i ustawia jej wartość na –1. W języku C nie ma jawnego typu 33/+2. Zamiast niego wartość logiczna jest symbo- lizowana przez każde wyrażenie, dające wartość całkowitą. Logiczny fałsz odpowiada wartości zero, podczas gdy każda wartość niezerowa odpowiada logicznej prawdzie. Gdy musisz przekazać wartość logiczną do funkcji API języka C, po prostu podaj wartość całkowitą o odpowiedniej wielkości, ustawioną jako 0 dla fałszu lub jako 1 dla prawdy. Łańcuchy istniejące w Pascalu nie posiadają swojego odpowiednika w C. Zamiast tego używa on tablic znaków, zakończonych znakiem pojedynczym o wartości zero (zna- kiem null). Ten format nazywany jest formatem zakończonym zerem lub łańcuchem ASCIIZ. „Łańcuchy” C są przekazywane jako wskaźniki do znaków (-+6 (cid:26)786 w C), które w Pascalu można przedstawić jako typ +6. Dla własnej wygody Kylix automatycznie umieszcza bajt o wartolci zero na ko5cu długich i szerokich ła5cuchów. Ułatwia to odwoływanie si do nich jako do ła5cuchów zako5czonych zerem, gdyr wystarczy po prostu zastosować rzutowanie do typu +6. W odróżnieniu od Pascala, C nie posiada operatorów manipulowania łańcuchami. Można nimi operować za pomocą grupy funkcji przeznaczonych specjalnie do tego celu, takich jak 786-+8, 786/2 czy 786.94. Gdybyś chciał używać także tych funkcji, są one dostęp- ne w Kyliksie po dołączeniu do programu modułu #7 87. Zmienne, struktury, unie oraz typy C przechowuje dane strukturalne na dwa sposoby: jako struktury lub jako unie. Struktu- ra występująca w C jest bardzo podobna do rekordu w Pascalu i są one ze sobą prawie zamienne. Poniższy przykład pokazuje strukturę w języku C oraz odpowiadający jej re- kord w Pascalu: 68 C:AndrzejPDFKylix. Czarna księga4-08.doc Rozdział 4. KKKK Podstawy C dla programistów Kyliksa 69 7869-88/  3218/)29,/6 32146-/ 73682)783-  84/8/6/-36. 8/9,/632128  6-/32128 2#83-#36828 /2. Należy zwrócić uwagę, że te konstrukcje nie są całkowicie równoważne. Przykład podany w Pascalu tworzy nowy typ o nazwie 8/, podczas gdy przykład w C nie two- rzy typu, gdyż do jego stworzenia potrzebne jest słowo kluczowe typedef, które zostałoby zastosowane następująco: 84/./07869-8  3218/)29,/6 32146-/ 73682)783- 8/ Słowo kluczowe 84/./0 służy w C do tworzenia nowego typu (w tym przypadku typu o nazwie 8/), który może być używany tak jak każdy „oficjalny” typ języka. Bez uży- cia słowa kluczowego typedef zmienne trzeba definiować przy użyciu słowa kluczowego 7869-8, tak jak pokazano poniżej: 7869-88/8/)203 Jeśli do stworzenia nowego typu zostało użyte słowo kluczowe 84/./0, słowo kluczo- we 7869-8 może zostać pominięte. Unia (9232) w języku C podobna jest do posiadającego warianty rekordu Pascala. Sta- nowi grupę zmiennych zajmujących w pamięci to samo miejsce. Oto przykład unii w C i odpowiadającego jej w Pascalu rekordu z wariantami: 84/./09232  3216/178/6):+ 92712/.7368;36.) );36.)  92712/.-+6,8/) ),8/) ),8/)),8/)  /178/6) 84/ /178/6)6/-36. -+7/8/30 :+, /178/6 +32128- :+ , 36. ) 36. #36828- :+,8/ )8/ )8/)8/8/- /2. W obu przykładach pola o rozmiarze bajtu zajmują w pamięci tyle samo miejsca, co pole 4-bajtowe. W rzeczywistości w języku C korzysta się z tej możliwości dosyć często, szczególnie, gdy potrzebny jest dostęp do poszczególnych bajtów zmiennej. C:AndrzejPDFKylix. Czarna księga4-08.doc 69 70 Czlć I KKKK Z Delphi do Kyliksa Jeśli musisz stworzyć rekord odpowiadający określonej strukturze lub unii języka C, zwróć szczególną uwagę na rozmiary poszczególnych pól składających się na niego i użyj właściwych typów Pascala odpowiadających typom języka C. Muszą one paso- wać do siebie i muszą zostać podane w tej samej kolejności, w przeciwnym razie poja- wią się błędy danych. Operatory jzyka C C posiada więcej operatorów niż mógłbyś przypuszczać. Często irytuje to programistów Pascala. Operatory te znajdziesz w przykładach kodu, a choć większość z nich posiada swój odpowiednik w Pascalu, istnieją operatory specyficzne wyłącznie dla języka C (na szczęście, można znaleźć sposób na obejście większości z takich operatorów). Tabela 4.4 przedstawia operatory, które spełniają w C i w Pascalu podobne funkcje. Podstawowe operatory matematyczne są w Pascalu przeciążone, mogą więc być używa- ne także jako operatory dla łańcuchów. Taka sytuacja nie zdarza się w języku C, w którym nie ma „ustawionych” typów, a do manipulowania łańcuchami używa się funkcji. Ope- ratory porównań numerycznych (na przykład „”, „”, „” oraz „”) są jednak iden- tyczne z odpowiednimi operatorami Pascala. Jak widać, wiele operatorów jest do siebie podobnych, ale posiada inną symbolikę. Kil- ka operatorów stosowanych jest w inny sposób – na przykład, unarny operator wyłu- skania wskaźnika jest stosowany w C po lewej stronie operanda, podczas gdy w Pascalu znajduje się po prawej stronie. Niektóre operatory mają inne znaczenie, ale działają po- dobnie. Istnieją jednak operatory, które są unikalne dla języka C. Są to: trójargumento- wy operator warunkowy, operatory inkrementacji i dekrementacji, operatory przypisań arytmetycznych, operator uzupełnienia do jedności oraz operator przecinka. Trójargumentowy operator warunkowy Trójargumentowy operator warunkowy przyjmuje postać „” i wygląda jak wyrażenie w nawiasach, tak jak w poniższym kodzie: , 0+7/869/- Pierwszy operand w tym operatorze warunkowym jest dowolnym wyrażeniem zwraca- jącym wartość logiczną (pamiętaj, że w C wartością logiczną jest każda wartość całkowita traktowana jako wartość zerowa lub niezerowa). W tym przypadku wyrażeniem tym jest „ .” Drugim operandem jest wartość, która zostanie zwrócona przez operator w przypadku prawdziwości wyrażenia, zaś trzecim operandem jest wartość, która zostanie zwrócona w przeciwnym razie. W Pascalu ten przykład można przepisać następująco: 0 8/2  0+7/ /7/  869/  Użycie trójargumentowego operatora warunkowego nie jest zbyt częste, gdyż sprawia on, że kod programu staje się trudniejszy do przeglądania. 70 C:AndrzejPDFKylix. Czarna księga4-08.doc Rozdział 4. KKKK Podstawy C dla programistów Kyliksa 71 Tabela 4.4. Równoważne operatory w C i w Pascalu Operator C Opis dla jzyka C Operator Pascala ’ (cid:31)  ’       oraz    (  (cid:31) ’ Dodawanie liczb i wskaźników. Odejmowanie liczb i wskaźników. Mnożenie liczb. Dzielenie całkowite i rzeczywiste (w zależności od typów operandów). Dzielenie modulo. Negacja liczby (operator unarny; stosowany do typów całkowitych). Przypisanie. Sprawdzenie równości. Logiczny AND (używany w wyrażeniach warunkowych). Logiczny OR (używany w wyrażeniach warunkowych). Logiczny NOT (używany w wyrażeniach warunkowych). Bitowe przesunięcie w lewo i w prawo. Bitowy AND. Bitowy OR. Bitowy XOR. Adres (operator unarny; stosowany dla zmiennych lub funkcji). Wyłuskanie wskaźnika (unarny; stosowany do typów wskaźnikowych). Selekcja struktury; stosowany do wskaźnika do struktury. Selekcja struktury; stosowany do egzemplarza struktury. 7/30,- ,84- Zwraca rozmiar zmiennej lub typu. Rzutowanie typów (na przykład ,28- ). Operatory inkrementacji i dekrementacji ’ (cid:31) : oraz 3. ’   2. 6 38 # oraz #6 2. 6 36  ( lub ( #/0,- 84,- (na przykład 28/1/6,- ) Jak sugerują ich nazwy, operator inkrementacji ( ) oraz operator dekrementacji (’’) inkrementują i dekrementują zmienne całkowite i wskaźnikowe. Są one podobne do procedur 2- i /- Pascala, jednakże w odróżnieniu od Pascala, operatory te (podobnie jak wszystkie inne operatory języka C) są w rzeczywistości funkcjami zwracającymi wartość operacji. Operatory te mogą być umieszczone przed lub za operandem. Choć operand jest inkrementowany lub dekrementowany bez względu na położenie operatora, położenie to wpływa na przyjmowane w wyrażeniu wartości. Ponieważ znaczenie obu tych operatorów jest identyczne, poniższy kod może stanowić przykład dla nich obu: 7368033  7368,+6 033 7368,+033  Na końcu tego przykładu zmienna foo jak mogliśmy oczekiwać, przyjmuje wartość 12. Prawdopodobnie podejrzewasz także, że zmienna ,+6 przyjmuje wartość 11, gdyż 033 jest obliczane jako wartość operanda po dokonaniu inkrementacji – operator jest umieszczony C:AndrzejPDFKylix. Czarna księga4-08.doc 71 72 Czlć I KKKK Z Delphi do Kyliksa przed operandem. Możesz się jednak nieco zdziwić dowiadując się, że wartością zmiennej ,+ także jest 11. Ponieważ operator występuje tu za operandem, wartość tego operanda jest stosowana w wyrażeniu przed dokonaniem inkrementacji. Operatory inkrementacji i dekrementacji spotkasz często w sytuacjach, w których po- mijana jest wartość wyrażenia. W takim przypadku umieszczenie operatora przed ope- randem lub za nim nie ma żadnego znaczenia, zaś efekt działania operatora jest identyczny jak działanie procedur 2- i /- w Pascalu. Na przykład instrukcja języka C:   jest identyczna z instrukcją Pascala: 2-,- Operatory przypisa(cid:24) arytmetycznych Programiści, którzy nie korzystają z języka C często uważają operatory przypisań aryt- metycznych za niepotrzebne skróty zapisu, jednak skoro zastosowanie ich jest bardzo powszechne, również je tutaj przedstawimy. Operatory te stanowią połączenie dowol- nego operatora arytmetycznego lub bitowego z operatorem przypisania, co ilustruje po- niższy przykład:   491  Powyższe dwie linie można w Pascalu przepisać jako:   4914916  Jak widać, operatory te są jedynie skrótem zapisu, ale prawie każdy programista C po- wie Ci, że krótki zapis to dobry zapis. Operator uzupełnienia do jednolci Operator uzupełnienia do jedności ( ) używany jest do konwersji dowolnej wartości całkowitej w celu jej uzupełnienia do jedności. Taka konwersja wiąże się z inwersją wszystkich bitów symbolizujących operand. Na przykład wartość całkowita 17 (binar- nie 00010001) została by zamieniona na wartość –18 (binarnie 11101110). Operator ten jest najczęściej używany do tworzenia masek logicznych przeznaczonych do manipulacji na bitach (gdy określony bit zmiennej ma zostać ustawiony na zero). W Pascalu operator uzupełnienia do jedności jest alternatywną formą słowa kluczowego 238. Gdy słowo to zostanie zastosowane dla wartości logicznej, po prostu zaneguje tę wartość. Jeśli jednak zostanie zastosowane dla typu całkowitego, wykona operację uzu- pełnienia do jedności. Dla przykładu spójrzmy na dwa zapisy. Pierwszy jest w języku C: -327892712/.-+6$) )#    92712/.-+6:+ :+ $) )# (cid:31);o-+-;+68,8(cid:31) 72 C:AndrzejPDFKylix. Czarna księga4-08.doc Rozdział 4. KKKK Podstawy C dla programistów Kyliksa 73 Drugi napisany został w Pascalu: -3278 8396+78/  :+6  +9/8/ +9/ +9/2.,38,8396+7-- Operator przecinka Skrótowość zapisu, o której wspominaliśmy wcześniej, może czasem przybierać dziwne formy. W języku C zdarzają się sytuacje, w których programista chce, by kilka instruk- cji zostało wykonanych kolejno, pragnąc jednocześnie, by syntaktycznie pozostały one wyrażeniem pojedynczym (zdarza się to często w pętlach 036, które omówimy już wkrótce). Operator przecinka jest po prostu przecinkiem umieszczanym pomiędzy in- strukcjami we wspomnianym wyżej celu. Rezultatem powyższej operacji jest wyrażenie składające się z kilku instrukcji, które zwraca wartość instrukcji znajdującej się po ostatnim przecinku. Pascal nie posiada odpowiednika tego operatora, lecz nie stanowi to problemu, gdyż w rzeczywistości w Pascalu nie jest on potrzebny. Natrafienie na instruk- cje oddzielone przecinkiem może jednak sprawiać kłopot programistom Pascala, którzy przyzwyczaili się do oddzielania instrukcji średnikami. Przykład użycia operatora prze- cinka pokażemy nieco dalej, w podrozdziale poświęconym zastosowaniu instrukcji 036 w języku C. Instrukcje sterujce i ptle Podobnie jak Pascal, język C posiada kilka konstrukcji pętli. Dwie z nich podobne są do pętli w Pascalu (pętle ;/ oraz .3 ;/). Trzecia z nich (pętla 036) nosi tę samą na- zwę, co jedna z pętli w Pascalu, lecz mechanizm jej działania jest nieco inny. Ptle while oraz do/while Pętle ;/ języka C są prawie identyczne z pętlami ;/ w Pascalu (z jedną ważną różnicą: o ile warunek pętli w Pascalu musi dawać wartość logiczną, o tyle warunek pętli w C może być wyrażeniem dającym dowolną wartość całkowitą.). Pętla wykonywana jest tak długo, jak długo wyrażenie posiada wartość różną od zera, lub do czasu nakaza- nia wcześniejszego opuszczenia pętli. Oznacza to, że wszystkie poniższe linie są w języku C poprawnymi pętlami: ;/, - ;/,’- ;/,++7)092-+);6+-++-+);+6837-)-+33;8+,-- Istnieją (i są dość często stosowane) także inne formy. Dzięki nim pętle mogą być kon- struowane w bardzo elastyczny sposób, czasem nawet kosztem większej ich złożoności i zmniejszonej czytelności. C:AndrzejPDFKylix. Czarna księga4-08.doc 73 74 Czlć I KKKK Z Delphi do Kyliksa Pętle .3 ;/ przyjmują w C następującą postać: .3 27869-+ ;/,;6+ /2/- Pętla .3 ;/ języka C jest bardzo podobna do pętli 6/4/+8 928 Pascala, z tym że pętla w C jest wykonywana, dopóki warunek jest spełniony (wyrażenie ma wartość róż- ną od zera), zaś w Pascalu pętla jest powtarzana do chwili spełnienia warunku (ma wartość true). Ptle for Pętla 036 może być uważana za kolejny stosowany w języku C zapis skrótowy. Pętla 036 (lub bardziej poprawnie, instrukcja 036) jest bardzo elastyczna i wydajna, ale może być również bardzo złożona. Jej koncepcja przypomina nieco pętlę 036 w Pascalu, gdyż tu także następuje inicjalizacja licznika pętli i aktualizowanie go podczas każdego jej przebiegu. Podstawowa forma tej instrukcji w języku C jest następująca: 036,;6+ /2/ ;6+ /2/;6+ /2/- 27869-+ Instrukcja tworzy ciało pętli i wykonywana jest zero lub więcej razy, w zależności od trzech zawartych w nawiasach wyrażeń. Pierwsze wyrażenie jest wyrażeniem inicjaliza- cyjnym. Jest obliczane raz (na początku instrukcji 036) i zwykle służy do inicjalizowania jednej lub więcej zmiennych licznika pętli. Drugie wyrażenie jest podobne do wyraże- nia warunkowego występującego w pętli ;/. Wyrażenie to jest obliczane przy każ- dym wejściu do pętli. Pętla kończy działanie w chwili, gdy wartością osiąganą przez to wyrażenie jest zero (lub gdy nakażemy wcześniejsze opuszczenie pętli). Ostatnie z wy- rażeń jest wyrażeniem modyfikującym. Obliczane jest po każdej iteracji pętli i służy zwykle do inkrementacji zmiennej licznika pętli. Oto przykład pętli 036: 036,. . . - 46280,.).- Przykład ten po prostu wypisuje cyfry od 0 do 9. Wyrażenie inicjalizacyjne ustawia zmienną . na zero. Wyrażenie warunkowe powoduje, że pętla jest wykonywana do- póty, dopóki wartość zmiennej idx jest mniejsza od dziesięciu. Wyrażenie modyfikujące zwiększa wartość z miennej . po każdy m wykonaniu pętli. Odpowiednik tej pętli w Pascalu mógłby wyglądać następująco: 36. 83.3  68/,.)  - W instrukcji for można jednak stosować także kilka innych rozwiązań. Każde z wyrażeń w nawiasach jest opcjonalne. Innymi słowy, można zastąpić je „instrukcją pustą” składającą się wyłącznie ze średnika. Poniższa instrukcja jest jak najbardziej poprawna (choć nie jest zbyt użyteczna, gdyż powoduje niekończące się wykonywanie bezużytecznej pętli): 036,- 74 C:AndrzejPDFKylix. Czarna księga4-08.doc Rozdział 4. KKKK Podstawy C dla programistów Kyliksa 75 W języku C dozwolone jest, by program modyfikował wartość indeksu pętli wewnątrz jej ciała. W Pascalu spowodowałoby to błąd kompilacji. Każde z wyrażeń występujących w nawiasach może stanowić rozdzieloną przecinkami listę instrukcji (o czym wspominaliśmy wcześniej, przy okazji omawiania operatora przecinka). Oto przykład: 036, )  786   ,786    -)786 786 - Choć kod ten nie zdobyłby nagrody za czytelność, zapisana w nim instrukcja jest poprawną instrukcją języka C. (Jeśli nie możesz zorientować się, do czego ona służy, wyjaśniamy, że po prostu usuwa spacje z łańcucha znaków o nazwie 786). Niestety, niektórzy pro- gramiści C — niektórzy, nie wszyscy — zdają się przyjmować instrukcje takie jak ta za możliwy do przyjęcia kod, co sprawia, że czytanie przykładowych programów staje się bardzo trudne. (Słyszałem kiedyś taką krytyczną uwagę na temat języka C: „Musi być coś nie tak z językiem, który łatwo pozwala na wskazanie instrukcji i stwierdzenie — ‹Założę się że zgadniesz do czego służy ta linia kodu.›”) Wychodzenie z ptli: break i continue Podobnie jak Pascal, język C posiada dwa strukturalne mechanizmy wcześniejszego opuszczania pętli. Tymi mechanizmami są instrukcje ,6/+ oraz -32829/; działają one identycznie jak procedury 6/+ i 32829/ w Pascalu. Instrukcja ,6/+ powoduje na- tychmiastowe zakończenie działania pętli i przejście do pierwszej instrukcji pojawiają- cej się za pętlą. Instrukcja continue nie powoduje wyjścia z pętli, lecz jedynie pominięcie pozostałej części jej ciała i rozpoczęcie następnej iteracji. Wskapniki Choć Pascal obsługuje wskaźniki, jednak jego programiści nie wykorzystują ich tak czę- sto jak programiści C. W języku C wskaźniki stanowią podstawowy element programu, są używane wszędzie i rozumiane przez wszystkich. (Lub prawie wszystkich — nawet zatwardziali programiści C mają z nimi czasem problemy.) Wskaźnik (ang. pointer) jest adresem określonego miejsca znajdującego się w pamięci. Wskaźniki umożliwiają programistom przekazywanie parametrów przez referencję (co omówimy wkrótce), pracę z dynamicznie alokowaną pamięcią oraz efektywne repre- zentowanie złożonych struktur danych. Wskaźniki ściśle wiążą się też z tablicami. Spójrzmy na przykład w języku C: 7368.  7368(cid:31)486 deklarujemy w nim zmienną całkowitą . oraz zmienną 486, będącą wskaźnikiem do egzemplarzy typu 7368. Na razie wskaźnik nie został zainicjalizowany, co oznacza, że wskazuje przypadkowe miejsce w pamięci. W tym momencie próba wyłuskania takiego C:AndrzejPDFKylix. Czarna księga4-08.doc 75 76 Czlć I KKKK Z Delphi do Kyliksa wskaźnika najprawdopodobniej doprowadziłaby do zniszczenia programu. Aby wskaź- nik 486 wskazywał na zmienną ., konieczne jest użycie poniższej instrukcji: 486. Użycie tego wskaźnika przez wyłuskanie go spowoduje pośrednie użycie zmiennej .. Na przykład: (cid:31)486  spowoduje, że wartość przechowywana w zmiennej . zostanie ustawiona na 30. Standardowym zastosowaniem wskaźników jest poruszanie się po tablicach i innych strukturach danych. Poniższy przykład pokazuje zawartość tablicy o nazwie :+9/7, wypisując ją na ekranie: 28:+9/7) ) ) ))  28(cid:31)486:+9/7 ;/,(cid:31)486 - 46280,.)(cid:31)486 - Na szczególną uwagę zasługują dwie linie. Pierwsza z nich to ta, w której deklarowana jest zmienna 486. Zwróć uwagę, że zmiennej 486, wskaźnikowi do wartości typu 28, przypisywana jest zmienna :+9/7 będąca odniesieniem do tablicy wartości typu 28. Wszystkie tablice w języku C mogą być przekazywane jako wskaźniki w wyniku zwy- czajnego pominięcia operacji indeksowania. W tym przypadku tablica :+9/7 (sama, bez indeksu) stanowi odpowiednik wskaźnika do typu 28, co umożliwia wykonanie te- go przypisania. Najczęściej spotkasz się z tym przy okazji użycia w języku C tablic znaków symbolizujących łańcuchy. Tablice te będą przekazywane zwykle przy użyciu bazowej nazwy tablicy jako typu -+6(cid:26). Drugą wartą uwagi linią jest ostatnia linia przykładu — instrukcja (cid:26)486 . Efektem działania tego wyrażenia jest uzyskanie wyłuskanej wartości wskaźnika w celu wypisa- nia jej na ekranie, a następnie inkrementacja samego wskaźnika. Inkrementacja wskaź- nika dokonana w ten sposób powoduje, że jest on zwiększany o określoną liczbę bajtów, zgodną z rozmiarem typu, na który wskazuje wskaźnik (ustalaną przez kompilator). Przy inkrementacji wskaźników, procedury 2- oraz /- w Pascalu działają w ten sam spo- sób. W wyniku przeprowadzenia tej operacji nie została zmieniana żadna pamięć (mimo zmiany wyglądu wyrażenia). Gdybyś chciał inkrementować zawartość pamięci wska- zywanej przez ten wskaźnik, musiałbyś użyć następującego wyrażenia: ,(cid:31)486-  Zwróć uwagę na użycie nawiasów (w celu określenia kolejności poszczególnych operacji). Innym powszechnym zastosowaniem wskaźników jest reprezentacja połączonych re- kordów (podobnych do występujących w listach połączonych). Najczęściej rekordy te (czyli węzły) są alokowane dynamicznie. Najpierw jednak tworzona jest deklaracja struktury węzła: 84/./07869-83./  -+6(cid:31)8/)2+/ 7869-83./(cid:31)2/8 3./ 76 C:AndrzejPDFKylix. Czarna księga4-08.doc Rozdział 4. KKKK Podstawy C dla programistów Kyliksa 77 W ten sposób tworzymy nowy typ noszący nazwę nazwie 3./. Dwukrotne pojawienie się nazwy typu, w pierwszej i ostatniej linii deklaracji, jest konieczne, aby umożliwić zastosowanie deklaracji w linii czwartej. Język C nie pozwala na używanie referencji wstępnych, więc typ Node nie mógłby zostać użyty przed stworzeniem go w ostatniej linii. Następnie tworzymy pierwszy węzeł listy połączonej, dynamicznie alokując pamięć za pomocą funkcji +3-12: 3./(cid:31)0678,3./(cid:31)-+3-,7/30,3./-- 0678’8/)2+/+/6 0678’2/8  Zwróć uwagę na zastosowanie rzutowania w celu konwersji wskaźnika do :3. (zwra- canego przez funkcję +3-12) na wskaźnik do typu 3./, a także na użycie operatora 7/3012 w celu określenia ilości bajtów, która powinna zostać zaalokowana. Zwróć także uwagę na użycie operatora wyboru pola struktury (’, zwanego także operatorem strzałki) przy odwoływaniu się do pól w nowo zaalokowanej strukturze 3./, a także na zastosowanie wartości   do zainicjalizowania wskaźnika do nieistniejącego następ- nego węzła listy. Wartość   w języku C stanowi odpowiednik wartości 2 w Pascalu. Na zakończenie tworzymy następny element listy i ustawiamy pierwszy element tak aby na niego wskazywał: 3./(cid:31)486,3./(cid:31)-+3-,7/30,3./-- 486’8/)2+/4/67 486’2/8  0678’2/8486 Teraz przejście przez elementy listy sprowadza się już tylko do użycia poniższej pętli: 036,4860678486 486486’2/8-  46280,72)486’8/)2+/-  W Pascalu cały ten przykład można zapisać następująco: 84/  3./(3./ 3./6/-36. 8/+/ +6 /8 3./ /2. :+6 678 3./  86 3./ /;,678- 678( 8/+/ +/6  678( /82 /;, 86- 86( 8/+/ 4/67  C:AndrzejPDFKylix. Czarna księga4-08.doc 77 78 Czlć I KKKK Z Delphi do Kyliksa 86( /82 678( /8 86 86678 ;/, 862-.3 ,/12  68/2, 86( 8/+/-  86 86( /8 /2. Podobnie jak Pascal, język C obsługuje także wskaźniki do funkcji. Jednak o ile w Pas- calu sposób deklaracji tego typu wskaźnika jest bardzo prosty, w języku C może on być bardzo trudny do odszyfrowania. Oto przykład deklaracji w Pascalu, w której tworzymy nowy typ o nazwie 92-832 86, będący wskaźnikiem do funkcji zwracającej wartość całkowitą i otrzymującej jako parametr pojedynczą wartość całkowitą. $4/ 92-832 8692-832,28/1/6-28/1/6 A oto identyczna instrukcja zapisana w języku C: 84/./028,(cid:31)92-832 86-,28- Jeśli sygnatury funkcji nie są skomplikowane, całość nie jest zbyt trudna do odczytania. Jednak gdy stają się one bardziej złożone, wskaźniki do funkcji są jednymi z najtrud- niejszych fragmentów kodu w języku C. Nawet doświadczeni programiści C muszą czasem się zatrzymać, wziąć głęboki oddech i powoli analizować deklarację wskaźnika do tak złożonej funkcji. Funkcje i „procedury” Wiele konwencji deklarowania i wywoływania funkcji i procedur stosowanych w języ- ku C oraz w Pascalu jest podobnych do siebie. Pod względem składni, funkcja w C nie różni się od procedury, która w C jest po prostu funkcją zwracającą :3.. Wszystkie funkcje w C zdefiniowane jako zwracające cokolwiek innego niż :3. muszą posługiwać się instrukcją 6/8962 zwracającą wartość do funkcji wywołującej. Oto przykład: 6/8962:+9/ Jej odpowiednikiem w Pascalu byłoby przypisanie wartości zwracanej do specjalnej, niedeklarowanej zmiennej noszącej nazwę /798. Odpowiednik powyższego przykła- du, w Pascalu wyglądałby następująco: /798 +9/ 8 Podobnie jak w Pascalu, argumenty funkcji języka C mogą być przekazywane przez da- ną wartość lub przez odniesienie. Jednak w odróżnieniu od Pascala, nie istnieją w tym języku żadne specjalne słowa kluczowe (takie jak np. :+6) wskazujące, że argument przekazywany jest przez odniesienie. Zamiast słów kluczowych używa się tu wskaźni- ków, tak jak w poniższym przykładzie: 78 C:AndrzejPDFKylix. Czarna księga4-08.doc Rozdział 4. KKKK Podstawy C dla programistów Kyliksa 79 :3.73/92-832,28:+9/ +6+)28(cid:31):+6 +6+-  :+9/ +6+  (cid:31):+6 +6+    Funkcja przedstawiona w tym przykładzie przyjmuje dwa parametry, zmieniając przed swoim powrotem wartość obu z nich. Pierwszy argument, valueParam, jest przekazywany przez wartość, zatem dokonane w nim zmiany nie są widoczne w funkcji wywołującej. Drugi parametr, :+6 +6+, przekazywany jest przez odniesienie, więc zmiany jego warto- ści dokonane w funkcji 73/92-832 będą widoczne także w funkcji wywołującej. Pozostałe zagadnienia W tym podrozdziale omówimy kilka różnic pomiędzy językiem C a Pascalem, których dotąd nie dało się nigdzie przyporządkować. Chodzi tu o indeksowanie tablic, dyna- miczną alokację pamięci oraz preprocesor języka C. Indeksy tablic W Pascalu programiści mogą deklarować swoje tablice wraz z indeksami obejmującymi dowolny zakres wartości całkowitych. W C indeksy tablic obejmują zawsze zakres od 0 do rozmiaru tablicy (minus jeden, bo indeks tablicy zaczyna się od zera). Na przykład, w tej definicji tablicy: 28:+9/7  poprawne wartości indeksów dla tablicy :+9/7 obejmują zakres od 0 do 9. Pamiętaj, że indeksy tablic w C zawsze zaczyn
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Kylix. Czarna księga
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ą: