Wydawnictwo Helion

ul. Chopina 6

44-100 Gliwice

tel. (32)230-98-63

e-mail: helion@helion.pl

PRZYK£ADOWY ROZDZIA£PRZYK£ADOWY ROZDZIA£

IDZ DOIDZ DO

ZAMÓW DRUKOWANY KATALOGZAMÓW DRUKOWANY KATALOG

KATALOG KSI¥¯EKKATALOG KSI¥¯EK

TWÓJ KOSZYKTWÓJ KOSZYK

CENNIK I INFORMACJECENNIK I INFORMACJE

ZAMÓW INFORMACJEO NOWO�CIACH

ZAMÓW INFORMACJEO NOWO�CIACH

ZAMÓW CENNIKZAMÓW CENNIK

CZYTELNIACZYTELNIA

FRAGMENTY KSI¥¯EK ONLINEFRAGMENTY KSI¥¯EK ONLINE

SPIS TRE�CISPIS TRE�CI

DODAJ DO KOSZYKADODAJ DO KOSZYKA

KATALOG ONLINEKATALOG ONLINE

C++. LeksykonkieszonkowyAutor: 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.

Spis treści 3

Spis treści

Wprowadzenie..........................................................................7Konwencje typograficzne..........................................................................8Podziękowania ...........................................................................................8Zgodność z językiem C .............................................................................8

Struktura programu.................................................................9Miejsce rozpoczęcia wykonywania .......................................................10Zakończenie wykonywania....................................................................12Pliki nagłówkowe.....................................................................................12Pliki źródłowe...........................................................................................14Dyrektywy preprocesora ........................................................................15Makra preprocesora.................................................................................20

Typy podstawowe .................................................................21bool.............................................................................................................21char oraz wchar_t.....................................................................................22short, int, long...........................................................................................23float, double, long double.......................................................................26

Typy złożone...........................................................................27Wyliczenia.................................................................................................28Tablice........................................................................................................29Łańcuchy ...................................................................................................33Wskaźniki..................................................................................................35Wskaźniki do składowych......................................................................38Referencje ..................................................................................................39Typy klasowe............................................................................................40

Konwersje i definicje typów................................................41Konwersje typów .....................................................................................41Definicje typów ........................................................................................44

4 C++. Leksykon kieszonkowy

Elementy leksykalne..............................................................44Komentarze ...............................................................................................45Identyfikatory ...........................................................................................46Słowa zastrzeżone....................................................................................47Literały.......................................................................................................47Operatory ..................................................................................................48Wyrażenia .................................................................................................63

Zakres.......................................................................................63Zakres lokalny ..........................................................................................64Zakres klasy ..............................................................................................64Zakres przestrzeni nazw.........................................................................65Zakres pliku ..............................................................................................65Inne zakresy ..............................................................................................66Obejmowanie zakresów..........................................................................66

Deklaracje ...............................................................................67Deklaracje zmiennych .............................................................................68Deklaracje funkcji.....................................................................................70Klasy pamięci............................................................................................73Kwalifikatory ............................................................................................75

Instrukcje.................................................................................78Instrukcje wyrażeniowe ..........................................................................78Instrukcje puste ........................................................................................78Instrukcje złożone ....................................................................................79Instrukcje iteracyjne.................................................................................80Instrukcje wyboru ....................................................................................82Instrukcje skoku .......................................................................................84

Przestrzenie nazw..................................................................87Deklaracje using .......................................................................................88Dyrektywy using......................................................................................89Anonimowe przestrzenie nazw.............................................................90

Klasy, struktury i unie .........................................................90Deklaracje obiektów ................................................................................91Dostęp do składowych............................................................................91Deklaracje danych składowych .............................................................92Deklaracje funkcji składowych ..............................................................96

Spis treści 5

Poziomy dostępu do składowych .......................................................101Funkcje i klasy zaprzyjaźnione ............................................................102Konstruktory...........................................................................................104Destruktory .............................................................................................108Deklaracje zagnieżdżone.......................................................................109Deklaracje zapowiadające.....................................................................110Struktury .................................................................................................111Unie ..........................................................................................................111

Dziedziczenie ........................................................................113Konstruktory a dziedziczenie ..............................................................114Destruktory a dziedziczenie.................................................................116Wirtualne funkcje składowe.................................................................117Abstrakcyjne klasy bazowe ..................................................................120Poziomy dostępu dla dziedziczenia....................................................121Dziedziczenie wielokrotne ...................................................................122Wirtualne klasy bazowe........................................................................124

Szablony ................................................................................125Klasy szablonowe...................................................................................125Funkcje szablonowe...............................................................................129

Przeciążanie..........................................................................132Przeciążanie funkcji ...............................................................................132Przeciążanie operatorów.......................................................................134

Zarządzanie pamięcią.........................................................137Przydział pamięci...................................................................................137Odzyskiwanie pamięci ..........................................................................140

Rzutowanie i informacjao typie czasu wykonywania..............................................141

Rzutowanie w stylu języka C...............................................................141Rzutowanie w języku C++ ...................................................................142Informacja o typie czasu wykonywania .............................................146

Obsługa wyjątków..............................................................147try .............................................................................................................148throw........................................................................................................148catch .........................................................................................................149Specyfikacje wyjątków ..........................................................................150

6 C++. Leksykon kieszonkowy

Biblioteka Standardowa C++ ...........................................151Przestrzeń nazw std...............................................................................152Realizacja Biblioteki Standardowej C..................................................153Standardowe pliki nagłówkowe C++ .................................................153Strumienie wejściowo-wyjściowe........................................................154

Skorowidz .............................................................................159

Wprowadzenie 7

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ładasię z krótkich rozdziałów, z których każdy podzielony jest natematy. 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ą innepozycje 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 BibliotekiStandardowej C, a także wiele nowych, takich jak StandardowaBiblioteka 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.

8 C++. Leksykon kieszonkowy

Konwencje typograficzne

W książce stosowane są następujące konwencje typograficzne:

������������ �� �������używana do oznaczania przykładowych fragmentów kodu,poleceń, słów kluczowych oraz nazw typów, zmiennych,funkcji i klas.

������������� ���������

używana do oznaczenia zastępowalnych parametrów.

Kursywaużywana do nazw plików oraz elementów wyróżnianychw tekście.

Podziękowania

Podziękowania należą się przede wszystkim Jonathanowi Gen-nickowi, redaktorowi w wydawnictwie O'Reilly, za wsparcieoraz wskazówki dotyczące tej książki. Dziękuję również UweSchnitkerowi, Danny'emu Kalevowi oraz Ronowi Passeriniemuza to, że poświęcili czas na lekturę i poczynili komentarze dowczesnego 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 napisaneprogramy w języku C na ogół skompilują się i będą działać jakoprogramy C++ (większość niezgodności bierze się ze ściślejszejkontroli typów realizowanej w języku C++). Programy w językuC++ 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.

Struktura programu 9

Nie należy jednak dać się zwieść podobieństwom pomiędzy Coraz C++ i uznać, że C++ jest jedynie banalną pochodną języka 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 ����� (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 programuNa 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 zdefiniowanejest 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łączeniekodu z tych plików przed kompilacją każdego pliku źródłowego

10 C++. Leksykon kieszonkowy

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 musizdefiniować, jest funkcja ����. W standardowej postaci funkcjata może nie przyjmować żadnych lub przyjmować dwa argu-menty podawane przez system operacyjny przy uruchomieniuprogramu, chociaż wiele implementacji języka C++ dopuszczatakże inne, dodatkowe parametry. Typem zwracanym funkcji ����jest ���. Na przykład:

�������������������������������������

Parametr ���� określa liczbę argumentów podanych w wierszupolecenia, a ���� jest tablicą łańcuchów zakończonych znakiempustym (��) — format języka C — zawierającą argumenty w kolej-ności ich występowania. Nazwa pliku wykonywalnego zapisanajest jako ������� i może być, lecz nie musi, poprzedzona pełnąścieżką. Wartość elementu ���������� wynosi 0.

Poniższy listing demonstruje kod funkcji ���� prostego progra-mu, który zachęca użytkownika do przeprowadzenia pewnychdziałań na koncie bankowym:

������ !���� ��"������ !�����"������ !�� ��#"������� $�� � %

������ &'������(�&

Struktura programu 11

����������������������������)'���������������(��%����������% ��#� ������%

�*�����"+��������( $�������*������+���%

,��� ���� �)����!!&-����� �&!!�������(� �-����� ��!! � �%

����!!&.�� � �,���/0&%���""������%

,������������)�� 1 10����!!&.�� � $���0&%���""������%�������( $�����������%#� ��%

�� 1,10����!!&.�� �,��� ��,��0&%���""������%�������(,��� ��,��������%#� ��%

�� 1/10 2�����%

*����0����!!&-� ������ &!! � �%3

12 C++. Leksykon kieszonkowy

3

� �����%3

Klasa reprezentująca konto bankowe zdefiniowana jest w póź-niejszym przykładzie. Na konto wpłacona zostaje kwota podanaw wierszu polecenia przy uruchomieniu programu. Do konwersjiargumentu wiersza polecenia z łańcucha na typ ��#� służy funkcja���* (z Biblioteki Standardowej C++).

Zakończenie wykonywania

Wykonywanie programu w języku C++ kończy się w momencieopuszczenia funkcji ���� na skutek wykonania instrukcji � ����.Wartość, która zostaje zwrócona, przekazywana jest z powrotemdo systemu operacyjnego i staje się wartością zwróconą danegopliku wykonywalnego. Jeśli w treści funkcji ���� nie występujeinstrukcja � ����, po wykonaniu wszystkich instrukcji funkcji���� zwrócona zostaje niejawnie wartość 0. Wykonywanie pro-gramu zakończyć można również przez wywołanie funkcji 2��(z Biblioteki Standardowej C++), która jako argument przyjmujewartość 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śnionajest w części „Deklaracje”),

Struktura programu 13

• definicji funkcji, za wyjątkiem tych zdefiniowanych jakofunkcje szablonowe lub funkcje typu ����� ,

• anonimowych przestrzeni nazw.

UWAGA

Pliki nagłówkowe w Bibliotece Standardowej C++ nieposiadają rozszerzenia .h — nie mają w ogóle rozszerzenia.

Często dla każdej ważniejszej klasy, którą definiujemy, tworzymyjeden plik nagłówkowy. Klasa '������ na przykład zdefiniowanajest w pliku nagłówkowym Account.h, którego zawartość przed-stawiono poniżej. Oczywiście pliki nagłówkowe służą także doinnych celów, a ponadto nie wszystkie definicje klas muszą zo-stać umieszczone w pliku nagłówkowym (np. klasy pomocniczedefiniowane są po prostu wewnątrz pliku źródłowego, w któ-rym są wykorzystywane).

��*� *'��456789� *�� '��456789

���'������)$�#���0'������� ��#� #�%

��� $���� ��#� ����%��� ,��� ��,� ��#� ����% ��#� � �-����� ������%

$����� 0 ��#� #����� %3%

� � �*

14 C++. Leksykon kieszonkowy

Implementacja tej klasy znajduje się w pliku Account.cpp. Pliknagłówkowy dołączyć można wewnątrz innego pliku za pomocądyrektywy preprocesora ������ (patrz punkt: „Dyrektywy pre-procesora”).

Ponieważ pliki nagłówkowe dołączane są często przez inne plikinagłówkowe, trzeba uważać, aby nie dołączyć kilka razy tegosamego pliku nagłówkowego, co spowodować może błędy kom-pilacji. Aby uniknąć takiej sytuacji, treść plików nagłówkowychzwyczajowo umieszcza się wewnątrz dyrektyw preprocesora��*� *, � *�� oraz � � �*, jak zrobiono to w powyższym przy-kładzie.

Taka metoda „opakowania” pliku nagłówkowego wymusza napreprocesorze konieczność przetestowania identyfikatora. Jeśli iden-tyfikator nie jest zdefiniowany, preprocesor definiuje go i prze-twarza zawartość danego pliku. Biorąc pod uwagę omawianyprzykład, zawartość pliku Account.h przetwarzana jest tylko wtedy,gdy nie jest zdefiniowany identyfikator '��456789, a pierwsząoperacją wykonywaną podczas tego przetwarzania jest zdefi-niowanie identyfikatora '��456789 w celu zapewnienia, aby danyplik nagłówkowy nie został dołączony po raz drugi. W celu za-gwarantowania niepowtarzalności jako identyfikator używanyjest zwykle symbol ���, gdzie � jest nazwą pliku nagłówkowegobez 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 kompilatortł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ę.

Struktura programu 15

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 '������ umieszczona jest w pliku na-główkowym Account.cpp, którego zawartość przedstawionoponiżej. Pliki źródłowe zawierają często więcej kodu niż tylkoimplementację pojedynczej klasy.

������ &'������(�&

'������00'������� ��#� #�)#����� :#%3

��� '������00 $���� ��#� ����)#����� ;:���%3

��� '������00,��� ��,� ��#� ����)#����� <:���%3

��#� '������00� �-����� ������)� ����#����� %3

Dyrektywy preprocesora

Preprocesor języka C++ wykorzystać można do przeprowadzeniaszeregu 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ąclewy ukośnik (�) na końcu wierszy pośrednich.

16 C++. Leksykon kieszonkowy

#define

Dyrektywa � *�� powoduje zastąpienie danego identyfikatoratekstem, który został po nim określony, we wszystkich miej-scach występowania tego identyfikatora w pliku źródłowym.Na przykład:

� *�� -5==.>8?@A.B�%����#�** ��-5==.>8?@A.3%

Jeśli po identyfikatorze nie podamy żadnego tekstu, wówczaspreprocesor zdefiniuje ten identyfikator w taki sposób, aby każdesprawdzenie istnienia jego definicji dało w wyniku wartość ��� ,a wszystkie wystąpienia identyfikatora w kodzie źródłowymzostały zastąpione tekstem pustym (czyli zostały usunięte). Z ta-kim przypadkiem mieliśmy do czynienia wcześniej przy defi-niowaniu identyfikatora '��456789.

UWAGA

W języku C++, zamiast stosowania dyrektywy ������� bar-dziej wskazane jest definiowanie danych stałych jako wyli-czeń oraz zmiennych i danych składowych deklarowanychz zastosowaniem słów kluczowych ��� lub �������.

Dyrektywa � *�� może również przyjmować argumenty w celuzastąpienia makroinstrukcji w tekście. Na przykład:

� *�� C@6���#������!�#��D���0�#��

���2:E�F:+���%

�:C@6�2�F�%GG7����������$��F$��� ��� �� ���,�����HE

W celu uniknięcia nieoczekiwanych problemów związanychz pierwszeństwem operatorów, parametry występujące w tekścieumieszczać należy w nawiasach, jak pokazano powyżej.

Struktura programu 17

UWAGA

W języku C++ bardziej wskazane jest stosowanie szablonóworaz funkcji typu �� ��� zamiast makroinstrukcji. Użycie sza-blonów i funkcji typu �� ��� eliminuje niespodziewane efektypowodowane przez makra, jak np. dwukrotna inkrementacjazmiennej � przez makro ����������, w przypadku gdy pa-rametr � jest mniejszy od � (przy zastępowaniu makra jakopierwszy parametr traktowane jest wyrażenie ���, a nie wy-nik operacji ���).

#undef

Dyrektywa ��� * usuwa definicję identyfikatora tak, aby spraw-dzenie jego istnienia dawało w wyniku wartość *�� . Na przykład:

��� *I4JJ@6J8.6'-I.K

#ifdef, #ifndef, #else, #endif

Dyrektywy ��* *, ��*� *, � � , � � �* stosowane są łącznie.Dyrektywa ��* * powoduje dołączenie przez preprocesor in-nego kodu w zależności od istnienia lub braku definicji danegoidentyfikatora. Na przykład:

��* *I4JJ@6J8.6'-I.K����!!&I������� ��#� &!! � �%� � ����!!&I������� ��#� &!! � �%� � �*

Użycie dyrektywy � � jest opcjonalne. Dyrektywa ��*� * działapodobnie, lecz powoduje dołączenie występującego po niej kodutylko wtedy, gdy brakuje definicji danego identyfikatora.

18 C++. Leksykon kieszonkowy

#if, #elif, #else, #endif

Dyrektywy ��*, � ��*, � � , � � �*, podobnie jak dyrektywy ��* *,stosowane są łącznie. Powodują one dołączenie lub wykluczenieprzez preprocesor kodu w zależności od prawdziwości danegowyrażenia. Na przykład:

��*�I4JJ@6J8I.L.I::I4JJ@6J8C@6MM�I4JJ@6J8=I'J�����!!&I��������������&!! � �%� ��*�I4JJ@6J8I.L.I::I4JJ@6J8C'NMM�I4JJ@6J8=I'J�� ��*I4JJ@6J8=I'J����!!&I���������� �� &!! � �%� � �*

Dyrektywa � ��* (else-if) służy do łańcuchowego łączenia szeregutestów, jak pokazano powyżej.

#include

Dyrektywa ������ 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ównagłówkowych zdefiniowanych przez użytkownika — w znakicudzysłowu. Na przykład:

������ !���� ��"������ &'������(�&

W zależności od sposobu podania nazwy pliku nagłówkowegopreprocesor przeszukiwał będzie inne ścieżki. To, które ścieżkizostaną przeszukane, zależy od systemu.

#error

Dyrektywa � ���� powoduje przerwanie kompilacji i wyświe-tlenie określonego tekstu. Na przykład:

Struktura programu 19

��* *I4JJ@6J8.6'-I.K� ����I���������� ���# ��#� � � �*

#line

Dyrektywa ���� sprawia, że preprocesor modyfikuje bieżący nu-mer wiersza zapisywany wewnętrznie przez kompilator podczaskompilacji w makrodefinicji 88I@6.88. Na przykład:

���� +��

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 88=@I.88.Na przykład:

���� +��&6 ,6�� (�$$&

#pragma

Niektóre operacje, które preprocesor może wykonać, są specy-ficzne dla implementacji. Dyrektywa �$����� umożliwia stero-wanie tymi operacjami przez podanie dyrektywy wraz z do-wolnymi parametrami w postaci wymaganej przez tę dyrektywę.Na przykład:

��* *I4JJ@6J8.6'-I.K�$������ �� �&I������ ��#� &�� � �*

W przypadku kompilatora Microsoft Visual C++ 6.0 dyrektywa� �� 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.

20 C++. Leksykon kieszonkowy

Makra preprocesora

Preprocesor języka C++ definiuje kilka makrodefinicji służącychdo wstawiania informacji do pliku źródłowego podczas kompi-lacji. Każdy identyfikator makra rozpoczyna się i kończy dwomaznakami podkreślenia, za wyjątkiem makra 88�$��$��, które nieposiada kończących znaków podkreślenia.

88I@6.88Rozwija się do bieżącego numeru wiersza kompilowanegopliku źródłowego.

88=@I.88Rozwija się do nazwy kompilowanego pliku źródłowego.

88K'7.88Rozwija się do daty kompilacji.

887@C.88Rozwija się do godziny kompilacji.

887@C.?7'CO88Rozwija się do daty i godziny kompilacji.

88?7K�88Będzie zdefiniowane, jeśli kompilator jest w pełni zgodnyze standardem ANSI C.

88�$��$��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.