Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00100 007774 10476177 na godz. na dobę w sumie
C++. Leksykon kieszonkowy - książka
C++. Leksykon kieszonkowy - książka
Autor: Liczba stron: 164
Wydawca: Helion Język publikacji: polski
ISBN: 83-7361-242-4 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> c++ - programowanie
Porównaj ceny (książka, ebook, audiobook).
C++ jest złożonym językiem o wielu subtelnych aspektach. Książka 'C++. Leksykon kieszonkowy' umożliwia programistom C++ szybkie sprawdzenie sposobu użycia oraz składni najczęściej używanych konstrukcji tego języka. Na jej stronach umieszczono możliwie jak najwięcej informacji, a jej niewielki rozmiar pozwala mieć ją zawsze przy sobie. 'C++. Leksykon kieszonkowy' opisuje następujące zagadnienia: Poza spełnianiem funkcji podręcznego leksykonu dla programistów C++, książka 'C++. Leksykon kieszonkowy' będzie także pomocna dla programistów języków Java oraz C, którzy przesiadają się na C++ lub tych, którzy w C++ programują od czasu do czasu. Te trzy języki są często mylące podobne. Książka ta umożliwia programistom zaznajomionym z językiem C lub Java szybkie orientowanie się w sposobie implementacji w C++.
'C++. Leksykon kieszonkowy' jest jednym z najbardziej zwięzłych i podręcznych opisów języka C++ dostępnych na rynku.
Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

C++. Leksykon kieszonkowy Autor: Kyle Loudon T³umaczenie: Przemys³aw Steæ ISBN: 83-7361-242-4 Tytu³ orygina³u: C++ Pocket Reference Format: B5, stron: 164 C++ jest z³o¿onym jêzykiem o wielu subtelnych aspektach. Ksi¹¿ka „C++. Leksykon kieszonkowy” umo¿liwia programistom C++ szybkie sprawdzenie sposobu u¿ycia oraz sk³adni najczêġciej u¿ywanych konstrukcji tego jêzyka. Na jej stronach umieszczono mo¿liwie jak najwiêcej informacji, a jej niewielki rozmiar pozwala mieæ j¹ zawsze przy sobie. „C++. Leksykon kieszonkowy” opisuje nastêpuj¹ce zagadnienia: • Instrukcje jêzyka C++ oraz dyrektywy preprocesora C++ • Przestrzenie nazw oraz zakres w C++ • Programowanie szablonowe oraz obs³uga wyj¹tków • Klasy oraz dziedziczenie • Typy jêzyka C++ oraz ich konwersje, w tym rzutowanie typów w C++ Poza spe³nianiem funkcji podrêcznego leksykonu dla programistów C++, ksi¹¿ka „C++. Leksykon kieszonkowy” bêdzie tak¿e pomocna dla programistów jêzyków Java oraz C, którzy przesiadaj¹ siê na C++ lub tych, którzy w C++ programuj¹ od czasu do czasu. Te trzy jêzyki s¹ czêsto myl¹ce podobne. Ksi¹¿ka ta umo¿liwia programistom zaznajomionym z jêzykiem C lub Java szybkie orientowanie siê w sposobie implementacji w C++. „C++. Leksykon kieszonkowy” jest jednym z najbardziej zwiêz³ych i podrêcznych opisów jêzyka C++ dostêpnych na rynku. IDZ DO IDZ DO PRZYK£ADOWY ROZDZIA£ PRZYK£ADOWY ROZDZIA£ SPIS TREĎCI SPIS TREĎCI KATALOG KSI¥¯EK KATALOG KSI¥¯EK KATALOG ONLINE KATALOG ONLINE ZAMÓW DRUKOWANY KATALOG ZAMÓW DRUKOWANY KATALOG TWÓJ KOSZYK TWÓJ KOSZYK DODAJ DO KOSZYKA DODAJ DO KOSZYKA CENNIK I INFORMACJE CENNIK I INFORMACJE ZAMÓW INFORMACJE ZAMÓW INFORMACJE O NOWOĎCIACH O NOWOĎCIACH ZAMÓW CENNIK ZAMÓW CENNIK CZYTELNIA CZYTELNIA FRAGMENTY KSI¥¯EK ONLINE FRAGMENTY KSI¥¯EK ONLINE Wydawnictwo Helion ul. Chopina 6 44-100 Gliwice tel. (32)230-98-63 e-mail: helion@helion.pl Spis treści Wprowadzenie..........................................................................7 Konwencje typograficzne...................................................y.......................8 Podziękowania ...................................................y........................................8 Zgodność z językiem C ...................................................y..........................8 Struktura programu.................................................................9 Miejsce rozpoczęcia wykonywania ...................................................y....10 Zakończenie wykonywania...................................................y.................12 Pliki nagłówkowe...................................................y..................................12 Pliki źródłowe...................................................y........................................14 Dyrektywy preprocesora ...................................................y.....................15 Makra preprocesora...................................................y..............................20 Typy podstawowe .................................................................21 bool...................................................y...................................................y.......21 char oraz wchar_t...................................................y..................................22 short, int, long...................................................y........................................23 float, double, long double...................................................y....................26 Typy złożone...........................................................................27 Wyliczenia...................................................y..............................................28 Tablice ...................................................y...................................................y..29 Łańcuchy ...................................................y................................................33 Wskaźniki...................................................y...............................................35 Wskaźniki do składowych...................................................y...................38 Referencje ...................................................y...............................................39 Typy klasowe...................................................y.........................................40 Konwersje i definicje typów................................................41 Konwersje typów ...................................................y..................................41 Definicje typów ...................................................y.....................................44 Spis treści 3 Elementy leksykalne..............................................................44 Komentarze ...................................................y............................................45 Identyfikatory ...................................................y........................................46 Słowa zastrzeżone...................................................y.................................47 Literały...................................................y...................................................y.47 Operatory ...................................................y...............................................48 Wyrażenia ...................................................y..............................................63 Zakres.......................................................................................63 Zakres lokalny ...................................................y.......................................64 Zakres klasy ...................................................y...........................................64 Zakres przestrzeni nazw...................................................y......................65 Zakres pliku ...................................................y...........................................65 Inne zakresy ...................................................y...........................................66 Obejmowanie zakresów ...................................................y.......................66 Deklaracje ...............................................................................67 Deklaracje zmiennych ...................................................y..........................68 Deklaracje funkcji...................................................y..................................70 Klasy pamięci...................................................y.........................................73 Kwalifikatory ...................................................y.........................................75 Instrukcje.................................................................................78 Instrukcje wyrażeniowe ...................................................y.......................78 Instrukcje puste ...................................................y.....................................78 Instrukcje złożone ...................................................y.................................79 Instrukcje iteracyjne ...................................................y..............................80 Instrukcje wyboru ...................................................y.................................82 Instrukcje skoku ...................................................y....................................84 Przestrzenie nazw..................................................................87 Deklaracje using ...................................................y....................................88 Dyrektywy using...................................................y...................................89 Anonimowe przestrzenie nazw ...................................................y..........90 Klasy, struktury i unie .........................................................90 Deklaracje obiektów ...................................................y.............................91 Dostęp do składowych...................................................y.........................91 Deklaracje danych składowych ...................................................y..........92 Deklaracje funkcji składowych ...................................................y...........96 4 C++. Leksykon kieszonkowy Poziomy dostępu do składowych ...................................................y....101 Funkcje i klasy zaprzyjaźnione ...................................................y.........102 Konstruktory...................................................y........................................104 Destruktory ...................................................y..........................................108 Deklaracje zagnieżdżone...................................................y....................109 Deklaracje zapowiadające...................................................y..................110 Struktury ...................................................y..............................................111 Unie ...................................................y...................................................y....111 Dziedziczenie ........................................................................113 Konstruktory a dziedziczenie ...................................................y...........114 Destruktory a dziedziczenie...................................................y..............116 Wirtualne funkcje składowe...................................................y..............117 Abstrakcyjne klasy bazowe ...................................................y...............120 Poziomy dostępu dla dziedziczenia...................................................y.121 Dziedziczenie wielokrotne ...................................................y................122 Wirtualne klasy bazowe...................................................y.....................124 Szablony ................................................................................125 Klasy szablonowe...................................................y................................125 Funkcje szablonowe...................................................y............................129 Przeciążanie..........................................................................132 Przeciążanie funkcji ...................................................y............................132 Przeciążanie operatorów...................................................y....................134 Zarządzanie pamięcią.........................................................137 Przydział pamięci...................................................y................................137 Odzyskiwanie pamięci ...................................................y.......................140 Rzutowanie i informacja o typie czasu wykonywania..............................................141 Rzutowanie w stylu języka C...................................................y............141 Rzutowanie w języku C++ ...................................................y................142 Informacja o typie czasu wykonywania .............................................146 Obsługa wyjątków ..............................................................147 try ...................................................y...................................................y.......148 throw...................................................y...................................................y..148 catch ...................................................y...................................................y...149 Specyfikacje wyjątków ...................................................y.......................150 Spis treści 5 Biblioteka Standardowa C++ ...........................................151 Przestrzeń nazw std...................................................y............................152 Realizacja Biblioteki Standardowej C..................................................153 Standardowe pliki nagłówkowe C++ .................................................153 Strumienie wejściowo-wyjściowe...................................................y.....154 Skorowidz .............................................................................159 6 C++. Leksykon kieszonkowy C++ Leksykon kieszonkowy Wprowadzenie „C++. Leksykon kieszonkowy” stanowi skrócony opis języka pro- gramowania C++ w postaci zdefiniowanej przez międzynaro- dowy standard INCITS/ISO/IEC 14882-1998. Książka składa się z krótkich rozdziałów, z których każdy podzielony jest na tematy. Wiele zagadnień zilustrowano precyzyjnymi, kanonicz- nymi przykładami. C++ jest bardzo obszernym językiem, który trudno opisać w for- mie leksykonu kieszonkowego. W rezultacie książka ta poświę- cona jest niemal wyłącznie prezentacji języka. Dostępne są inne pozycje z serii O Reilly, które opisują Bibliotekę Standardową C++, będącą samą w sobie obszernym tematem. Biblioteka Stan- dardowa C++ zawiera wszystkie funkcje i możliwości Biblioteki Standardowej C, a także wiele nowych, takich jak Standardowa Biblioteka Szablonów (STL) czy strumienie I/O. Książka napisana została dla czytelników o zróżnicowanym stop- niu zaawansowania i doświadczenia w programowaniu w C++. Dla doświadczonych programistów C++ będzie wyjątkowo skon- densowanym leksykonem najczęściej wykorzystywanych możli- wości języka. Nowicjusze powinni najpierw zapoznać się z ja- kimś wprowadzeniem do języka, a później wrócić do tego lek- sykonu, aby poznać określone zagadnienia. Wprowadzenie 7 Konwencje typograficzne W książce stosowane są następujące konwencje typograficyzne: \EKQPMCQUVCđGLU\GTQMQħEK używana do oznaczania przykładowych fragmentów kodu, poleceń, słów kluczowych oraz nazw typów, zmiennych, funkcji i klas. -WTU[YCQUVCđGLU\GTQMQħEK używana do oznaczenia zastępowalnych parametrów. Kursywa używana do nazw plików oraz elementów wyróżnianych w tekście. Podziękowania Podziękowania należą się przede wszystkim Jonathanowi Gen- nickowi, redaktorowi w wydawnictwie O Reilly, za wsparcie oraz wskazówki dotyczące tej książki. Dziękuję również yUwe Schnitkerowi, Danny emu Kalevowi oraz Ronowi Passeriniemu za to, że poświęcili czas na lekturę i poczynili komentarze do wczesnego szkicu książki. Zgodność z językiem C Z pewnymi drobnymi wyjątkami język C++ stworzony został jako rozszerzenie języka C. Oznacza to, że właściwie napisane programy w języku C na ogół skompilują się i będą działać jako programy C++ (większość niezgodności bierze się ze ściślejszej kontroli typów realizowanej w języku C++). Programy w języku C++ wyglądają zazwyczaj podobnie pod względem składnio- wym do programów w języku C i wykorzystują wiele pierwot- nych możliwości i funkcji języka C. 8 C++. Leksykon kieszonkowy Nie należy jednak dać się zwieść podobieństwom pomiędzy C oraz C++ i uznać, że C++ jest jedynie banalną pochodną jęyzyka C. W rzeczywistości bowiem jest to rozbudowany język, który wzbo- gaca C o bardzo istotne elementy, a mianowicie o: • programowanie obiektowe, • programowanie generyczne wykorzystujące szablony, • przestrzenie nazw, funkcje typu KPNKPG (czyli wstawiane w miejscu wywołania), • • przeciążanie operatorów i funkcji, • lepsze mechanizmy zarządzania pamięcią, • referencje, • bezpieczniejsze formy rzutowania, • informację o typie czasu wykonywania, • obsługę wyjątków, • rozszerzoną Bibliotekę Standardową. Struktura programu Na najwyższym poziomie program w języku C++ składa się z jednego lub wielu plików źródłowych zawierających kod źró- dłowy C++. We wszystkich tych plikach łącznie zdefiniowane jest dokładnie jedno miejsce rozpoczęcia wykonywania pro- gramu i być może wiele miejsc jego zakończenia. W plikach źródłowych C++ często importowany jest, czyli dołą- czany (ang. included), dodatkowy kod źródłowy znajdujący się w tzw. plikach nagłówkowych (ang. header files). Za dołączenie kodu z tych plików przed kompilacją każdego pliku źródłowego Struktura programu 9 odpowiedzialny jest preprocesor języka C++. Jednocześnie pre- procesor, poprzez zastosowanie tzw. dyrektyw preprocesora, mo- że wykonać także inne operacje. Plik źródłowy po przetworze- niu przez preprocesor zwany jest jednostką translacji (ang. trans- lation unit). Miejsce rozpoczęcia wykonywania Oznaczonym początkiem programu C++, który programista musi zdefiniować, jest funkcja OCKP. W standardowej postaci funkcja ta może nie przyjmować żadnych lub przyjmować dwa argu- menty podawane przez system operacyjny przy uruchomieniu programu, chociaż wiele implementacji języka C++ dopuszcza także inne, dodatkowe parametry. Typem zwracanym funkcji OCKP jest KPV. Na przykład: KPVOCKP KPVOCKP KPVCTIEEJCT CTIX=? Parametr CTIE określa liczbę argumentów podanych w wierszu polecenia, a CTIX jest tablicą łańcuchów zakończonych znakiem pustym ( ) — format języka C — zawierającą argumenty w kolej- ności ich występowania. Nazwa pliku wykonywalnego zapisana jest jako CTIX=? i może być, lecz nie musi, poprzedzona pełną ścieżką. Wartość elementu CTIX=CTIE? wynosi 0. Poniższy listing demonstruje kod funkcji OCKP prostego progra- mu, który zachęca użytkownika do przeprowadzenia pewnych działań na koncie bankowym: KPENWFGKQUVTGCO KPENWFGEOCVJ KPENWFGEUVFNKD WUKPIPCOGURCEGUVF KPENWFG#EEQWPVJ 10 C++. Leksykon kieszonkowy KPVOCKP KPVCTIEEJCT CTIX=? ] #EEQWPVCEEQWPV   EJCTCEVKQP FQWDNGCOQWPV KH CTIE  CEEQWPVFGRQUKV CVQH CTIX=?  YJKNG VTWG ] EQWV$CNCPEGKU CEEQWPVIGV$CNCPEG GPFN EQWV PVGTFYQTS EKP CEVKQP UYKVEJ CEVKQP ] ECUG F  EQWV PVGTFGRQUKV EKP COQWPV CEEQWPVFGRQUKV COQWPV  DTGCM ECUG Y  EQWV PVGTYKVJFTCYCN EKP COQWPV CEEQWPVYKVJFTCY COQWPV  DTGCM ECUG S  GZKV   FGHCWNV EQWV$CFEQOOCPFGPFN _ Struktura programu 11 _ TGVWTP _ Klasa reprezentująca konto bankowe zdefiniowana jest w póź- niejszym przykładzie. Na konto wpłacona zostaje kwota podana w wierszu polecenia przy uruchomieniu programu. Do konwersji argumentu wiersza polecenia z łańcucha na typ FQWDNG służy funkcja CVQH (z Biblioteki Standardowej C++). Zakończenie wykonywania Wykonywanie programu w języku C++ kończy się w momenciye opuszczenia funkcji OCKP na skutek wykonania instrukcji TGVWTP. Wartość, która zostaje zwrócona, przekazywana jest z powrotem do systemu operacyjnego i staje się wartością zwróconą danego pliku wykonywalnego. Jeśli w treści funkcji OCKP nie występuje instrukcja TGVWTP, po wykonaniu wszystkich instrukcji funkcji OCKP zwrócona zostaje niejawnie wartość 0. Wykonywanie pro- gramu zakończyć można również przez wywołanie funkcji GZKV (z Biblioteki Standardowej C++), która jako argument przyjmuje wartość zwracaną pliku wykonywalnego. Pliki nagłówkowe Pliki nagłówkowe zawierają kod źródłowy, który ma zostać dołą- czony do wielu różnych plików. Posiadają zwykle rozszerzenie .h. W pliku nagłówkowym umieszczamy każdy kod, który ma zo- stać dołączony w wielu miejscach. Plik nagłówkowy nie powi- nien nigdy zawierać: • definicji zmiennych oraz statycznych danych składowych (różnica pomiędzy deklaracjami a definicjami wyjaśniona jest w części „Deklaracje”), 12 C++. Leksykon kieszonkowy • definicji funkcji, za wyjątkiem tych zdefiniowanych jako funkcje szablonowe lub funkcje typu KPNKPG, • anonimowych przestrzeni nazw. UWAGA Pliki nagłówkowe w Bibliotece Standardowej C++ nie posiadają rozszerzenia .h — nie mają w ogóle rozszerzenia. Często dla każdej ważniejszej klasy, którą definiujemy, tyworzymy jeden plik nagłówkowy. Klasa #EEQWPV na przykład zdefiniowana jest w pliku nagłówkowym Account.h, którego zawartość przed- stawiono poniżej. Oczywiście pliki nagłówkowe służą także do innych celów, a ponadto nie wszystkie definicje klas muszą zo- stać umieszczone w pliku nagłówkowym (np. klasy pomocnicze definiowane są po prostu wewnątrz pliku źródłowego, w któ- rym są wykorzystywane). KHPFGH# 1706A* FGHKPG# 1706A* ENCUU#EEQWPV ] RWDNKE #EEQWPV FQWDNGD  XQKFFGRQUKV FQWDNGCOV  XQKFYKVJFTCY FQWDNGCOV  FQWDNGIGV$CNCPEG EQPUV RTKXCVG FQWDNGDCNCPEG _ GPFKH Struktura programu 13 Implementacja tej klasy znajduje się w pliku Account.cpp. Plik nagłówkowy dołączyć można wewnątrz innego pliku za pomocą dyrektywy preprocesora KPENWFG (patrz punkt: „Dyrektywy pre- procesora”). Ponieważ pliki nagłówkowe dołączane są często przez inne pliki nagłówkowe, trzeba uważać, aby nie dołączyć kilka razy tego samego pliku nagłówkowego, co spowodować może błędy kom- pilacji. Aby uniknąć takiej sytuacji, treść plików nagłówkowych zwyczajowo umieszcza się wewnątrz dyrektyw preprocesora KHPFGH, FGHKPG oraz GPFKH, jak zrobiono to w powyższym przy- kładzie. Taka metoda „opakowania” pliku nagłówkowego wymusza na preprocesorze konieczność przetestowania identyfikatora. Jeśli iden- tyfikator nie jest zdefiniowany, preprocesor definiuje go i prze- twarza zawartość danego pliku. Biorąc pod uwagę omawiany przykład, zawartość pliku Account.h przetwarzana jest tylko wtedy, gdy nie jest zdefiniowany identyfikator # 1706A*, a pierwszą operacją wykonywaną podczas tego przetwarzania jest zdefi- niowanie identyfikatora # 1706A* w celu zapewnienia, aby dany plik nagłówkowy nie został dołączony po raz drugi. W celu za- gwarantowania niepowtarzalności jako identyfikator używany jest zwykle symbol :A*, gdzie : jest nazwą pliku nagłówkowego bez rozszerzenia. Pliki źródłowe Pliki źródłowe C++ posiadają zwykle rozszerzenie .cpp i zawie- rają kod źródłowy języka C++. Podczas kompilacji kompilator tłumaczy normalnie pliki źródłowe na pliki wynikowe (ang. ob- ject files), które często posiadają rozszerzenie .obj lub .o. Konso- lidator łączy następnie pliki wynikowe w końcowy plik wyko- nywalny lub bibliotekę. 14 C++. Leksykon kieszonkowy Często, choć oczywiście nie zawsze, dla każdej ważniejszej klasy, którą implementujemy, tworzymy jeden plik źródłowy. Na przy- kład implementacja klasy #EEQWPV umieszczona jest w pliku na- główkowym Account.cpp, którego zawartość przedstawiono poniżej. Pliki źródłowe zawierają często więcej kodu niż tylko implementację pojedynczej klasy. KPENWFG#EEQWPVJ #EEQWPV#EEQWPV FQWDNGD ] DCNCPEGD _ XQKF#EEQWPVFGRQUKV FQWDNGCOV ] DCNCPEG COV _ XQKF#EEQWPVYKVJFTCY FQWDNGCOV ] DCNCPEGCOV _ FQWDNG#EEQWPVIGV$CNCPEG EQPUV ] TGVWTPDCNCPEG _ Dyrektywy preprocesora Preprocesor języka C++ wykorzystać można do przeprowadzenia szeregu pożytecznych operacji sterowanych przez kilka dyrek- tyw. Każda dyrektywa rozpoczyna się od znaku  jako pierw- szego znaku w wierszu, który nie jest znakiem odstępu. Pojedyn- czą dyrektywę można zapisać w wielu wierszach, wstawiając lewy ukośnik ( ) na końcu wierszy pośrednich. Struktura programu 15 #define Dyrektywa FGHKPG powoduje zastąpienie danego identyfikatora tekstem, który został po nim określony, we wszystkich miej- scach występowania tego identyfikatora w pliku źródłowym. Na przykład: FGHKPG$7(( 4A5+  EJCTDWHHGT=$7(( 4A5+ _ Jeśli po identyfikatorze nie podamy żadnego tekstu, wówczas preprocesor zdefiniuje ten identyfikator w taki sposób, aby każde sprawdzenie istnienia jego definicji dało w wyniku wartość VTWG, a wszystkie wystąpienia identyfikatora w kodzie źródłowym zostały zastąpione tekstem pustym (czyli zostały usunięte). Z ta- kim przypadkiem mieliśmy do czynienia wcześniej przy defi- niowaniu identyfikatora # 1706A*. UWAGA W języku C++, zamiast stosowania dyrektywy FGHKPG bar- dziej wskazane jest definiowanie danych stałych jako wyli- czeń oraz zmiennych i danych składowych deklarowanych z zastosowaniem słów kluczowych EQPUV lub UVCVKEEQPUV. Dyrektywa FGHKPG może również przyjmować argumenty w celu zastąpienia makroinstrukcji w tekście. Na przykład: FGHKPG/+0 CD  C  D ! C  D KPVZ[\ \/+0 Z[ 6CKPUVTWMELCRT\[RKUWLG\OKGPPGL \YCTVQħè W celu uniknięcia nieoczekiwanych problemów związanych z pierwszeństwem operatorów, parametry występujące w tekście umieszczać należy w nawiasach, jak pokazano powyżej. 16 C++. Leksykon kieszonkowy UWAGA W języku C++ bardziej wskazane jest stosowanie szabloónów oraz funkcji typu KPNKPG zamiast makroinstrukcji. Użycie sza- blonów i funkcji typu KPNKPG eliminuje niespodziewane efekty powodowane przez makra, jak np. dwukrotna inkrementacja zmiennej Z przez makro /+0 Z [ , w przypadku gdy pa- rametr C jest mniejszy od D (przy zastępowaniu makra jako pierwszy parametr traktowane jest wyrażenie Z , a nie wy- nik operacji Z ). #undef Dyrektywa WPFGH usuwa definicję identyfikatora tak, aby spraw- dzenie jego istnienia dawało w wyniku wartość HCNUG. Na przykład: WPFGH.1))+0)A 0#$. #ifdef, #ifndef, #else, #endif Dyrektywy KHFGH, KHPFGH, GNUG, GPFKH stosowane są łącznie. Dyrektywa KHFGH powoduje dołączenie przez preprocesor in- nego kodu w zależności od istnienia lub braku definicji danego identyfikatora. Na przykład: KHFGH.1))+0)A 0#$. EQWV.QIIKPIKUGPCDNGFGPFN GNUG EQWV.QIIKPIKUFKUCDNGFGPFN GPFKH Użycie dyrektywy GNUG jest opcjonalne. Dyrektywa KHPFGH działa podobnie, lecz powoduje dołączenie występującego po niej kodu tylko wtedy, gdy brakuje definicji danego identyfikatoyra. Struktura programu 17 #if, #elif, #else, #endif Dyrektywy KH, GNKH, GNUG, GPFKH, podobnie jak dyrektywy KHFGH, stosowane są łącznie. Powodują one dołączenie lub wykluczenie przez preprocesor kodu w zależności od prawdziwości danego wyrażenia. Na przykład: KH .1))+0)A. 8 ..1))+0)A/+0 .1))+0)A(.#) EQWV.QIIKPIKUOKPKOCNGPFN GNKH .1))+0)A. 8 ..1))+0)A/#: .1))+0)A(.#) GNKH.1))+0)A(.#) EQWV.QIIKPIKUUVCPFCTFGPFN GPFKH Dyrektywa GNKH (else-if) służy do łańcuchowego łączenia szeregu testów, jak pokazano powyżej. #include Dyrektywa KPENWFG powoduje dołączenie przez preprocesor in- nego pliku, zazwyczaj pliku nagłówkowego. Nazwy standardo- wych plików nagłówkowych ujmujemy w nawiasy ostre, a plików nagłówkowych zdefiniowanych przez użytkownika — w znaki cudzysłowu. Na przykład: KPENWFGKQUVTGCO KPENWFG#EEQWPVJ W zależności od sposobu podania nazwy pliku nagłówkowego preprocesor przeszukiwał będzie inne ścieżki. To, które ścieżki zostaną przeszukane, zależy od systemu. #error Dyrektywa GTTQT powoduje przerwanie kompilacji i wyświe- tlenie określonego tekstu. Na przykład: 18 C++. Leksykon kieszonkowy KHFGH.1))+0)A 0#$. GTTQT.QIIKPIUJQWNFPQVDGGPCDNGF GPFKH #line Dyrektywa NKPG sprawia, że preprocesor modyfikuje bieżący nu- mer wiersza zapisywany wewnętrznie przez kompilator podczas kompilacji w makrodefinicji AA.+0 AA. Na przykład: NKPG Po numerze wiersza można opcjonalnie podać nazwę pliku ujętą w znaki cudzysłowu. Powoduje to zmianę nazwy pliku wew- nętrznie zapisywanej przez kompilator w makrodefinicji AA(+. AA. Na przykład: NKPG0GY0COGERR #pragma Niektóre operacje, które preprocesor może wykonać, są specy- ficzne dla implementacji. Dyrektywa RTCIOC umożliwia stero- wanie tymi operacjami przez podanie dyrektywy wraz z do- wolnymi parametrami w postaci wymaganej przez tę dyrektywę. Na przykład: KHFGH.1))+0)A 0#$. RTCIOCOGUUCIG .QIIKPIGPCDNGF GPFKH W przypadku kompilatora Microsoft Visual C++ 6.0 dyrektywa OGUUCIG nakazuje preprocesorowi wyświetlenie komunikatu pod- czas kompilacji w momencie napotkania zawierającego ją wier- sza. Dyrektywa ta wymaga jednego parametru — komunikatu, który ma zostać wyświetlony. Jego tekst, ujęty w znaki cudzy- słowu, umieszczany jest w nawiasach. Struktura programu 19 Makra preprocesora Preprocesor języka C++ definiuje kilka makrodefinicji służących do wstawiania informacji do pliku źródłowego podczas kompi- lacji. Każdy identyfikator makra rozpoczyna się i kończy dwoma znakami podkreślenia, za wyjątkiem makra AAERNWURNWU, które nie posiada kończących znaków podkreślenia. AA.+0 AA Rozwija się do bieżącego numeru wiersza kompilowanego pliku źródłowego. AA(+. AA Rozwija się do nazwy kompilowanego pliku źródłowego. AA #6 AA Rozwija się do daty kompilacji. AA6+/ AA Rozwija się do godziny kompilacji. AA6+/ 56#/2AA Rozwija się do daty i godziny kompilacji. AA56 AA Będzie zdefiniowane, jeśli kompilator jest w pełni zgodny ze standardem ANSI C. AAERNWURNWU Będzie zdefiniowane, jeśli kompilowany program jest pro- gramem w języku C++. Sposób, w jaki kompilator ustala, czy dany program jest programem C++, zależy od kom- pilatora. Może istnieć konieczność ustawienia odpowied- niej opcji kompilatora lub kompilator może brać pod uwa- gę rozszerzenie pliku źródłowego. 20 C++. Leksykon kieszonkowy
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

C++. Leksykon kieszonkowy
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ą: