Wydawnictwo Helion
ul. Chopina 6
44-100 Gliwice
tel. (32)230-98-63
e-mail: [email protected]
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==.>[email protected]�%����#�** ��-5==.>[email protected]%
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:
��� *[email protected]'-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:
��* *[email protected]'-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:
��*�[email protected]::I4JJ@6J8C@6MM�I4JJ@6J8=I'J�����!!&I��������������&!! � �%� ��*�[email protected]::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
��* *[email protected]'-I.K� ����I���������� ���# ��#� � � �*
#line
Dyrektywa ���� sprawia, że preprocesor modyfikuje bieżący nu-mer wiersza zapisywany wewnętrznie przez kompilator podczaskompilacji w makrodefinicji [email protected]. 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 [email protected] 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:
��* *[email protected]'-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.
[email protected] się do bieżącego numeru wiersza kompilowanegopliku źródłowego.
[email protected] się do nazwy kompilowanego pliku źródłowego.
88K'7.88Rozwija się do daty kompilacji.
[email protected] 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.
Top Related