Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00161 009725 11027748 na godz. na dobę w sumie
C++. Programowanie zorientowane obiektowo. Vademecum profesjonalisty - książka
C++. Programowanie zorientowane obiektowo. Vademecum profesjonalisty - książka
Autor: Liczba stron: 560
Wydawca: Helion Język publikacji: polski
ISBN: 83-7361-195-9 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> c++ - programowanie
Porównaj ceny (książka, ebook, audiobook).
C++ jest obecnie wiodącym językiem programowania obiektowego. Jego podstawowymi zaletami w stosunku do innych języków obiektowych jest wysoka efektywność i uniwersalność. Stosowany jest do tworzenia komercyjnego oprogramowania oraz efektywnych rozwiązań złożonych problemów.

Książka krok po kroku omawia wszystkie właściwości języka i wyjaśnia sposoby ich praktycznego użycia. Przedstawione przykłady programów nie są zbyt skomplikowane, by nie odrywać Twojej uwagi od omawianych zagadnień, ale nie są też sztucznie uproszczone. Kluczowym założeniem języka C++ jest programowanie z wykorzystaniem szablonów, które umożliwiają tworzenie rozwiązań o wysokim poziomie ogólności - na przykład implementację polimorfizmu. Nicolai Josuttis omawia możliwość łączenia szablonów z programowaniem obiektowym, która decyduje o potężnych możliwościach języka C++ jako narzędzia tworzenia wydajnych programów. W tym zakresie książka wykracza daleko poza podstawy. Książka ta jest idealnym podręcznikiem umożliwiającym studiowanie języka C++ w domowym zaciszu. Prezentuje ona zagadnienia podstawowe, ale w wielu przypadkach przekracza je dostarczając prawdziwie profesjonalnej wiedzy.

Wyczerpujący, szczegółowy, praktyczny i aktualny podręcznik programowania w języku C++
Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

IDZ DO IDZ DO PRZYK£ADOWY ROZDZIA£ PRZYK£ADOWY ROZDZIA£ SPIS TREĎCI SPIS TREĎCI 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 C++. Projektowanie zorientowane obiektowo. Vademecum profesjonalisty Autor: Nicolai M. Josuttis T³umaczenie: Jaromir Senczyk ISBN: 83-7361-195-9 Tytu³ orygina³u: Object-Oriented Programming in C++ Format: B5, stron: 560 C++ jest obecnie wiod¹cym jêzykiem programowania obiektowego. Jego podstawowymi zaletami w stosunku do innych jêzyków obiektowych jest wysoka efektywnoġæ i uniwersalnoġæ. Stosowany jest do tworzenia komercyjnego oprogramowania oraz efektywnych rozwi¹zañ z³o¿onych problemów. Ksi¹¿ka krok po kroku omawia wszystkie w³aġciwoġci jêzyka i wyjaġnia sposoby ich praktycznego u¿ycia. Przedstawione przyk³ady programów nie s¹ zbyt skomplikowane, by nie odrywaæ Twojej uwagi od omawianych zagadnieñ, ale nie s¹ te¿ sztucznie uproszczone. Kluczowym za³o¿eniem jêzyka C++ jest programowanie z wykorzystaniem szablonów, które umo¿liwiaj¹ tworzenie rozwi¹zañ o wysokim poziomie ogólnoġci — na przyk³ad implementacjê polimorfizmu. Nicolai Josuttis omawia mo¿liwoġæ ³¹czenia szablonów z programowaniem obiektowym, która decyduje o potê¿nych mo¿liwoġciach jêzyka C++ jako narzêdzia tworzenia wydajnych programów. W tym zakresie ksi¹¿ka wykracza daleko poza podstawy. • Wprowadzenie do C++ i programowania obiektowego • Podstawowe pojêcia jêzyka C++ • Programowanie klas • Dziedziczenie i polimorfizm • Sk³adowe dynamiczne i statyczne • Szablony jêzyka C++ • Szczegó³owe omówienie standardowej biblioteki wejġcia-wyjġcia Ksi¹¿ka ta jest idealnym podrêcznikiem umo¿liwiaj¹cym studiowanie jêzyka C++ w domowym zaciszu. Prezentuje ona zagadnienia podstawowe, ale w wielu przypadkach przekracza je dostarczaj¹c prawdziwie profesjonalnej wiedzy. Wyczerpuj¹cy, szczegó³owy, praktyczny i aktualny podrêcznik programowania w jêzyku C++. 5RKUVTGħEK 2TGFOQYC   4QFKCđ 1MUKæľEG   1.1. Dlaczego napisałem tę książkę?...................................................o...................................13 1.2. Wymagania ...................................................o...................................................o...............14 1.3. Organizacja książki ...................................................o...................................................o...14 1.4. W jaki sposób należy czytać książkę? ...................................................o.........................15 1.5. Przykłady programów i dodatkowe informacje ...................................................o...........15 4QFKCđ 9RTQYCFGPKGLú[M KRTQITCOQYCPKGQDKGMVQYG   2.1. Język C++ ...................................................o...................................................o.................19 2.1.1. Kryteria projektowania ...................................................o......................................19 2.1.2. Historia języka ...................................................o...................................................o20 2.2. C++ jako język programowania obiektowego ...................................................o.............20 2.2.1. Obiekty, klasy i instancje ...................................................o...................................21 2.2.2. Klasy w języku C++ ...................................................o..........................................23 2.2.3. Hermetyzacja danych...................................................o.........................................25 2.2.4. Dziedziczenie ...................................................o...................................................o..27 2.2.5. Polimorfizm ...................................................o...................................................o....28 2.3. Inne koncepcje języka C++...................................................o..........................................29 2.3.1. Obsługa wyjątków ...................................................o.............................................30 2.3.2. Szablony...................................................o...................................................o..........30 2.3.3. Przestrzenie nazw...................................................o...............................................32 2.4. Terminologia...................................................o...................................................o.............32 4QFKCđ 2QFUVCYQYGRQLúEKCLú[MC   3.1. Pierwszy program ...................................................o...................................................o.....35 3.1.1. „Hello, World!”...................................................o..................................................35 3.1.2. Komentarze w języku C++ ...................................................o................................37 3.1.3. Funkcja main() ...................................................o...................................................o37 3.1.4. Wejście i wyjście ...................................................o...............................................39 3.1.5. Przestrzenie nazw...................................................o...............................................40 3.1.6. Podsumowanie ...................................................o...................................................o41 3.2. Typy, operatory i instrukcje sterujące...................................................o..........................41 3.2.1. Pierwszy program, który przeprowadza obliczenia ..............................................41 3.2.2. Typy podstawowe ...................................................o..............................................44 4 C++. Programowanie zorientowane obiektowo. Vademecum profesjonalisty 3.2.3. Operatory ...................................................o...................................................o........48 3.2.4. Instrukcje sterujące ...................................................o............................................54 3.2.5. Podsumowanie ...................................................o...................................................o57 3.3. Funkcje i moduły ...................................................o...................................................o......58 3.3.1. Pliki nagłówkowe...................................................o...............................................58 3.3.2. Plik źródłowy zawierający definicję ...................................................o..................60 3.3.3. Plik źródłowy zawierający wywołanie funkcji ...................................................o..60 3.3.4. Kompilacja i konsolidacja...................................................o..................................61 3.3.5. Rozszerzenia nazw plików...................................................o.................................62 3.3.6. Systemowe pliki nagłówkowe i biblioteki...................................................o.........63 3.3.7. Preprocesor ...................................................o...................................................o.....63 3.3.8. Przestrzenie nazw...................................................o...............................................66 3.3.9. Słowo kluczowe static...................................................o........................................67 3.3.10. Podsumowanie ...................................................o.................................................69 3.4. Łańcuchy znaków ...................................................o...................................................o.....70 3.4.1. Pierwszy przykład programu wykorzystującego łańcuchy znaków .....................70 3.4.2. Kolejny przykładowy program wykorzystujący łańcuchy znaków ......................74 3.4.3. Przegląd operacji na łańcuchach znaków ...................................................o..........78 3.4.4. Łańcuchy znaków i C-łańcuchy...................................................o.........................79 3.4.5. Podsumowanie ...................................................o...................................................o80 3.5. Kolekcje ...................................................o...................................................o....................80 3.5.1. Program wykorzystujący klasę vector ...................................................o...............81 3.5.2. Program wykorzystujący klasę deque...................................................o................82 3.5.3. Wektory i kolejki ...................................................o...............................................83 3.5.4. Iteratory...................................................o...................................................o...........84 3.5.5. Przykładowy program wykorzystujący listy...................................................o......87 3.5.6. Przykłady programów wykorzystujących kontenery asocjacyjne ........................88 3.5.7. Algorytmy ...................................................o...................................................o.......92 3.5.8. Algorytmy wielozakresowe ...................................................o...............................96 3.5.9. Iteratory strumieni...................................................o..............................................98 3.5.10. Uwagi końcowe ...................................................o.............................................100 3.5.11. Podsumowanie ...................................................o...............................................101 3.6. Obsługa wyjątków ...................................................o...................................................o..102 3.6.1. Powody wprowadzenia obsługi wyjątków...................................................o.......102 3.6.2. Koncepcja obsługi wyjątków...................................................o...........................104 3.6.3. Standardowe klasy wyjątków ...................................................o..........................105 3.6.4. Przykład obsługi wyjątku...................................................o.................................106 3.6.5. Obsługa nieoczekiwanych wyjątków...................................................o...............109 3.6.6. Funkcje pomocnicze obsługi błędów...................................................o...............110 3.6.7. Podsumowanie ...................................................o.................................................111 3.7. Wskaźniki, tablice i C-łańcuchy ...................................................o................................112 3.7.1. Wskaźniki ...................................................o...................................................o.....112 3.7.2. Tablice...................................................o...................................................o...........115 3.7.3. C-łańcuchy ...................................................o...................................................o....117 3.7.4. Podsumowanie ...................................................o.................................................121 3.8. Zarządzanie pamięcią za pomocą operatorów new i delete..........................................121 3.8.1. Operator new...................................................o...................................................o.123 3.8.2. Operator delete...................................................o.................................................123 Spis treści 5 3.8.3. Dynamiczne zarządzanie pamięcią tablic ...................................................o........124 3.8.4. Obsługa błędów związanych z operatorem new .................................................126 3.8.5. Podsumowanie ...................................................o.................................................126 3.9. Komunikacja ze światem zewnętrznym ...................................................o....................126 3.9.1. Parametry wywołania programu ...................................................o......................126 3.9.2. Dostęp do zmiennych środowiska ...................................................o...................128 3.9.3. Przerwanie działania programu...................................................o........................128 3.9.4. Wywoływanie innych programów ...................................................o...................129 3.9.5. Podsumowanie ...................................................o.................................................130 4QFKCđ 2TQITCOQYCPKGMNCU   4.1. Pierwsza klasa: Fraction ...................................................o............................................131 4.1.1. Zanim rozpoczniemy implementację ...................................................o...............131 4.1.2. Deklaracja klasy Fraction ...................................................o................................134 4.1.3. Struktura klasy ...................................................o.................................................135 4.1.4. Funkcje składowe...................................................o.............................................138 4.1.5. Konstruktory ...................................................o...................................................o.138 4.1.6. Przeciążenie funkcji ...................................................o.........................................140 4.1.7. Implementacja klasy Fraction ...................................................o..........................141 4.1.8. Wykorzystanie klasy Fraction...................................................o..........................146 4.1.9. Tworzenie obiektów tymczasowych...................................................o................151 4.1.10. Notacja UML ...................................................o.................................................152 4.1.11. Podsumowanie ...................................................o...............................................152 4.2. Operatory klas...................................................o...................................................o.........153 4.2.1. Deklaracje operatorów ...................................................o.....................................153 4.2.2. Implementacja operatorów...................................................o...............................156 4.2.3. Posługiwanie się operatorami ...................................................o..........................163 4.2.4. Operatory globalne...................................................o...........................................164 4.2.5. Ograniczenia w definiowaniu operatorów ...................................................o.......165 4.2.6. Specjalne właściwości niektórych operatorów ...................................................o166 4.2.7. Podsumowanie ...................................................o.................................................170 4.3. Optymalizacja efektywności kodu...................................................o.............................170 4.3.1. Wstępna optymalizacja klasy Fraction ...................................................o............171 4.3.2. Domyślne parametry funkcji...................................................o............................174 4.3.3. Funkcje rozwijane w miejscu wywołania ...................................................o........175 4.3.4. Optymalizacja z perspektywy użytkownika ...................................................o....177 4.3.5. Instrukcja using...................................................o................................................178 4.3.6. Deklaracje pomiędzy instrukcjami ...................................................o..................179 4.3.7. Konstruktory kopiujące...................................................o....................................181 4.3.8. Podsumowanie ...................................................o.................................................182 4.4. Referencje i stałe...................................................o...................................................o.....183 4.4.1. Konstruktory kopiujące i przekazywanie parametrów .......................................183 4.4.2. Referencje ...................................................o...................................................o.....184 4.4.3. Stałe...................................................o...................................................o............. 4.4.4. Stałe funkcje składowe ...................................................o....................................189 4.4.5. Klasa Fraction wykorzystująca referencje ...................................................o.......190 4.4.6. Wskaźniki stałych i stałe wskaźniki ...................................................o................193 4.4.7. Podsumowanie ...................................................o.................................................195 ..187 6 C++. Programowanie zorientowane obiektowo. Vademecum profesjonalisty 4.5. Strumienie wejścia i wyjścia...................................................o......................................196 4.5.1. Strumienie ...................................................o...................................................o.....196 4.5.2. Korzystanie ze strumieni...................................................o..................................197 4.5.3. Stan strumienia...................................................o.................................................203 4.5.4. Operatory wejścia i wyjścia dla typów definiowanych przez użytkownika .......205 4.5.5. Podsumowanie ...................................................o.................................................214 4.6. Klasy zaprzyjaźnione i inne typy...................................................o...............................214 4.6.1. Automatyczna konwersja typów...................................................o......................215 4.6.2. Słowo kluczowe explicit ...................................................o..................................217 4.6.3. Funkcje zaprzyjaźnione ...................................................o...................................217 4.6.4. Funkcje konwersji...................................................o............................................223 4.6.5. Problemy automatycznej konwersji typu...................................................o.........225 4.6.6. Inne zastosowania słowa kluczowego friend ...................................................o...227 4.6.7. Słowo kluczowe friend i programowanie obiektowe..........................................227 4.6.8. Podsumowanie ...................................................o.................................................228 4.7. Obsługa wyjątków w klasach ...................................................o....................................229 4.7.1. Powody zastosowania obsługi wyjątków w klasie Fraction ...............................229 4.7.2. Obsługa wyjątków w klasie Fraction ...................................................o...............230 4.7.3. Klasy wyjątków ...................................................o...............................................237 4.7.4. Ponowne wyrzucenie wyjątku ...................................................o.........................237 4.7.5. Wyjątki w destruktorach ...................................................o..................................238 4.7.6. Wyjątki i deklaracje interfejsów ...................................................o......................238 4.7.7. Hierarchie klas wyjątków ...................................................o................................239 4.7.8. Projektowanie klas wyjątków ...................................................o..........................242 4.7.9. Wyrzucanie standardowych wyjątków ...................................................o............244 4.7.10. Bezpieczeństwo wyjątków...................................................o.............................244 4.7.11. Podsumowanie ...................................................o...............................................245 4QFKCđ KGFKEGPKGKRQNKOQTHKO  5.1. Dziedziczenie pojedyncze...................................................o..........................................249 5.1.1. Klasa Fraction jako klasa bazowa...................................................o....................249 5.1.2. Klasa pochodna RFraction ...................................................o...............................251 5.1.3. Deklaracja klasy pochodnej RFraction ...................................................o............253 5.1.4. Dziedziczenie i konstruktory ...................................................o...........................255 5.1.5. Implementacja klas pochodnych...................................................o......................258 5.1.6. Wykorzystanie klasy pochodnej ...................................................o......................260 5.1.7. Konstruktory obiektów klasy bazowej...................................................o.............262 5.1.8. Podsumowanie ...................................................o.................................................264 5.2. Funkcje wirtualne ...................................................o...................................................o...264 5.2.1. Problemy z przesłanianiem funkcji...................................................o..................265 5.2.2. Statyczne i dynamiczne wiązanie funkcji ...................................................o........267 5.2.3. Przeciążenie i przesłanianie ...................................................o.............................271 5.2.4. Dostęp do parametrów klasy bazowej ...................................................o.............273 5.2.5. Destruktory wirtualne ...................................................o......................................274 5.2.6. Właściwe sposoby stosowania dziedziczenia ...................................................o..275 5.2.7. Inne pułapki przesłaniania funkcji ...................................................o...................279 5.2.8. Dziedziczenie prywatne i deklaracje dostępu ...................................................o..281 5.2.9. Podsumowanie ...................................................o.................................................284 Spis treści 7 5.3. Polimorfizm ...................................................o...................................................o............285 5.3.1. Czym jest polimorfizm?...................................................o...................................285 5.3.2. Polimorfizm w języku C++...................................................o..............................287 5.3.3. Przykład polimorfizmu w języku C++...................................................o.............288 5.3.4. Abstrakcyjna klasa bazowa GeoObj ...................................................o................291 5.3.5. Zastosowanie polimorfizmu wewnątrz klas...................................................o.....298 5.3.6. Polimorfizm nie wymaga instrukcji wyboru...................................................o....304 5.3.7. Przywracanie obiektowi jego rzeczywistej klasy ...............................................304 5.3.8. Projektowanie przez kontrakt ...................................................o..........................308 5.3.9. Podsumowanie ...................................................o.................................................309 5.4. Dziedziczenie wielokrotne...................................................o.........................................310 5.4.1. Przykład dziedziczenia wielokrotnego ...................................................o............310 5.4.2. Wirtualne klasy bazowe ...................................................o...................................315 5.4.3. Identyczność i adresy ...................................................o.......................................318 5.4.4. Wielokrotne dziedziczenie tej samej klasy bazowej...........................................321 5.4.5. Podsumowanie ...................................................o.................................................321 5.5. Pułapki projektowania z użyciem dziedziczenia ...................................................o.......322 5.5.1. Dziedziczenie kontra zawieranie ...................................................o.....................322 5.5.2. Błędy projektowania: ograniczanie dziedziczenia..............................................323 5.5.3. Błędy projektowania: dziedziczenie zmieniające wartość..................................324 5.5.4. Błędy projektowania: dziedziczenie zmieniające interpretację wartości............326 5.5.5. Unikajmy dziedziczenia! ...................................................o.................................327 5.5.6. Podsumowanie ...................................................o.................................................327 4QFKCđ 5MđCFQYGF[PCOKEPGKUVCV[EPG   6.1. Składowe dynamiczne ...................................................o...............................................329 6.1.1. Implementacja klasy String...................................................o..............................329 6.1.2. Konstruktory i składowe dynamiczne...................................................o..............334 6.1.3. Implementacja konstruktora kopiującego ...................................................o........336 6.1.4. Destruktory ...................................................o...................................................o...337 6.1.5. Implementacja operatora przypisania ...................................................o..............337 6.1.6. Pozostałe operatory ...................................................o..........................................339 6.1.7. Wczytywanie łańcucha klasy String ...................................................o................341 6.1.8. Komercyjne implementacje klasy String ...................................................o.........344 6.1.9. Inne zastosowania składowych dynamicznych...................................................o346 6.1.10. Podsumowanie ...................................................o...............................................347 6.2. Inne aspekty składowych dynamicznych...................................................o...................348 6.2.1. Składowe dynamiczne w obiektach stałych...................................................o.....348 6.2.2. Funkcje konwersji dla składowych dynamicznych.............................................351 6.2.3. Funkcje konwersji i instrukcje warunkowe ...................................................o.....353 6.2.4. Stałe jako zmienne ...................................................o...........................................355 6.2.5. Zapobieganie wywołaniu domyślnych operacji..................................................357 6.2.6. Klasy zastępcze ...................................................o................................................358 6.2.7. Obsługa wyjątków z użyciem parametrów ...................................................o......361 6.2.8. Podsumowanie ...................................................o.................................................365 6.3. Dziedziczenie i klasy o składowych dynamicznych...................................................o..365 6.3.1. Klasa CPPBook::String jak klasa bazowa ...................................................o.......365 6.3.2 Klasa pochodna ColString ...................................................o...............................368 6.3.3. Dziedziczenie funkcji zaprzyjaźnionych ...................................................o.........371 8 C++. Programowanie zorientowane obiektowo. Vademecum profesjonalisty 6.3.4. Plik źródłowy klasy pochodnej ColString ...................................................o.......373 6.3.5. Aplikacja klasy ColString ...................................................o................................374 6.3.6. Dziedziczenie specjalnych funkcji dla składowych dynamicznych ...................375 6.3.7. Podsumowanie ...................................................o.................................................376 6.4. Klasy zawierające klasy...................................................o.............................................376 6.4.1. Obiekty jako składowe innych klas ...................................................o.................377 6.4.2. Implementacja klasy Person ...................................................o............................377 6.4.3. Podsumowanie ...................................................o.................................................383 6.5. Składowe statyczne i typy pomocnicze ...................................................o.....................383 6.5.1. Statyczne składowe klas ...................................................o..................................384 6.5.2. Deklaracje typu wewnątrz klasy ...................................................o......................389 6.5.3. Typy wyliczeniowe jako statyczne stałe klasy ...................................................o391 6.5.4. Klasy zagnieżdżone i klasy lokalne ...................................................o.................392 6.5.5. Podsumowanie ...................................................o.................................................393 4QFKCđ 5CDNQP[  7.1. Dlaczego szablony? ...................................................o...................................................o395 7.1.1. Terminologia...................................................o...................................................o.396 7.2. Szablony funkcji ...................................................o...................................................o.....396 7.2.1. Definiowanie szablonów funkcji ...................................................o.....................397 7.2.2. Wywoływanie szablonów funkcji...................................................o....................398 7.2.3. Praktyczne wskazówki dotyczące używania szablonów ....................................399 7.2.4. Szablony i automatyczna konwersja typu...................................................o........399 7.2.5. Przeciążanie szablonów ...................................................o...................................400 7.2.6. Zmienne lokalne...................................................o...............................................402 7.2.7. Podsumowanie ...................................................o.................................................402 7.3. Szablony klas ...................................................o...................................................o..........403 7.3.1. Implementacja szablonu klasy Stack ...................................................o...............403 7.3.2. Zastosowanie szablonu klasy Stack ...................................................o.................406 7.3.3. Specjalizacja szablonów klas ...................................................o...........................408 7.3.4. Domyślne parametry szablonu...................................................o.........................410 7.3.5. Podsumowanie ...................................................o.................................................412 7.4. Inne parametry szablonów ...................................................o.........................................412 7.4.1. Przykład zastosowania innych parametrów szablonów ......................................412 7.4.2. Ograniczenia parametrów szablonów ...................................................o..............415 7.4.3. Podsumowanie ...................................................o.................................................416 7.5. Inne zagadnienia związane z szablonami ...................................................o..................416 7.5.1. Słowo kluczowe typename ...................................................o..............................416 7.5.2. Składowe jako szablony...................................................o...................................417 7.5.3. Polimorfizm statyczny z użyciem szablonów...................................................o..420 7.5.4. Podsumowanie ...................................................o.................................................424 7.6. Szablony w praktyce ...................................................o..................................................424 7.6.1. Kompilacja kodu szablonu...................................................o...............................424 7.6.2. Obsługa błędów ...................................................o...............................................429 7.6.3. Podsumowanie ...................................................o.................................................430 4QFKCđ 5VCPFCTFQYCDKDNKQVGMCYGLħEKCKY[LħEKCYUEGIÎđCEJ   8.1. Standardowe klasy strumieni ...................................................o.....................................433 8.1.1. Klasy strumieni i obiekty strumieni...................................................o.................434 8.1.2. Stan strumienia...................................................o.................................................436 Spis treści 9 8.1.3. Operatory standardowe ...................................................o....................................439 8.1.4. Funkcje standardowe ...................................................o.......................................440 8.1.5. Manipulatory...................................................o...................................................o.443 8.1.6. Definicje formatu ...................................................o.............................................445 8.1.7. Internacjonalizacja ...................................................o...........................................455 8.1.8. Podsumowanie ...................................................o.................................................458 8.2. Dostęp do plików ...................................................o...................................................o....458 8.2.1. Klasy strumieni dla plików ...................................................o..............................458 8.2.2. Wykorzystanie klas strumieni plików...................................................o..............459 8.2.3. Znaczniki plików ...................................................o.............................................461 8.2.4. Jawne otwieranie i zamykanie plików ...................................................o.............462 8.2.5. Swobodny dostęp do plików...................................................o............................463 8.2.6. Przekierowanie standardowych kanałów do plików...........................................466 8.2.7. Podsumowanie ...................................................o.................................................467 8.3. Klasy strumieni łańcuchów...................................................o........................................467 8.3.1. Klasy strumieni łańcuchów...................................................o..............................468 8.3.2. Operator rzutowania leksykalnego ...................................................o..................470 8.3.3. Strumienie C-łańcuchów...................................................o..................................472 8.3.4. Podsumowanie ...................................................o.................................................474 4QFKCđ +PPGYđCħEKYQħEKLú[MC  9.1. Dodatkowe informacje o bibliotece standardowej...................................................o.....475 9.1.1. Operacje na wektorach...................................................o.....................................475 9.1.2. Operacje wspólne dla wszystkich kontenerów STL ...........................................482 9.1.3. Algorytmy STL...................................................o................................................482 9.1.4. Ograniczenia wartości numerycznych ...................................................o.............488 9.1.5. Podsumowanie ...................................................o.................................................492 9.2. Definiowanie specjalnych operatorów...................................................o.......................493 9.2.1. Inteligentne wskaźniki ...................................................o.....................................493 9.2.2. Obiekty funkcji ...................................................o................................................496 9.2.3. Podsumowanie ...................................................o.................................................500 9.3. Inne aspekty operatorów new i delete...................................................o........................500 9.3.1. Operatory new i delete, które nie wyrzucają wyjątków......................................500 9.3.2. Określanie położenia obiektu...................................................o...........................501 9.3.3. Funkcje obsługi operatora new ...................................................o........................501 9.3.4. Przeciążanie operatorów new i delete...................................................o..............506 9.3.5. Dodatkowe parametry operatora new ...................................................o..............509 9.3.6. Podsumowanie ...................................................o.................................................510 9.4. Wskaźniki funkcji i wskaźniki składowych...................................................o...............510 9.4.1. Wskaźniki funkcji ...................................................o............................................510 9.4.2. Wskaźniki składowych ...................................................o....................................511 9.4.3. Wskaźniki składowych i zewnętrzne interfejsy ..................................................514 9.4.4. Podsumowanie ...................................................o.................................................515 9.5. Łączenie programów w językach C i C++...................................................o.................516 9.5.1. Łączenie zewnętrzne ...................................................o........................................516 9.5.2. Pliki nagłówkowe w językach C i C++ ...................................................o...........517 9.5.3. Kompilacja funkcji main() ...................................................o...............................517 9.5.4. Podsumowanie ...................................................o.................................................518 10 C++. Programowanie zorientowane obiektowo. Vademecum profesjonalisty 9.6. Dodatkowe słowa kluczowe ...................................................o......................................518 9.6.1. Unie...................................................o...................................................o...............518 9.6.2. Typy wyliczeniowe ...................................................o..........................................519 9.6.3. Słowo kluczowe volatile ...................................................o..................................520 9.6.4. Podsumowanie ...................................................o.................................................520 4QFKCđ 2QFUWOQYCPKG  10.1. Hierarchia operatorów języka C++...................................................o..........................521 10.2. Właściwości operacji klas...................................................o........................................523 10.3. Zasady automatycznej konwersji typów...................................................o..................524 10.4. Przydatne zasady programowania i projektowania ...................................................o.525 QFCVGM# $KDNKQITCHKC   QFCVGM$ 5đQYPKM   5MQTQYKF   Rozdział 7. 5CDNQP[ W rozdziale tym przedstawiona zostanie koncepcja szablonów. Szablony umożliwiają parametryzację kodu dla różnych typów. Dzięki temu na przykład funkcja wyznaczają- ca najmniejszą wartość lub klasa kolekcji może zostać zaimplementowana, zanim usta- lony zostanie typ parametru funkcji lub elementu kolekcji. Kod generowany na podsta- wie szablonu nie przetwarza jednak dowolnych typów: w momencie, gdy ustalony zostanie typ parametru. Obowiązuje również zwykła keontrola zgodności typów. Najpierw przedstawione zostaną szablony funkcji, a następnie szablony klas. Omówie- nie szablonów zakończymy przedstawieniem sposobów ich wykorzystania, w tym spe- cjalnych technik projektowania. Więcej informacji na temat szablonów można znaleźć w eksiążce C++ Templates — The Complete Guide1, której autorami są Nicolai M. Josuttis i David Vandevoorde (patrz VandevoordeJosuttisTemplate). Książka ta zawiera podobne wprowadzenie do proble- matyki szablonów, wyczerpujący opis szablonów, szeregu technik kodowania i zaawan- sowanych zastosowań szablonów.  NCEGIQUCDNQP[! W językach programowania, które wiążą zmienne z określonym typem danych, często pojawia się sytuacja wymagająca wielokrotnego zdefiniowania tej samej funkcji dla różnych typów parametrów. Typowym przykładem jest funkcja zwracająca większą z przekazanych jej dwóch wartości. Musi ona zostać zaimplementowana osobno dla każdego typu, dla którego chcemy ja wykorzystywać. W języku C można tego uniknąć, posługując się makrodefinicją. Ponieważ działanie makrodefinicji polega na mecha- nicznym zastępowaniu przez preprocesor jednego tekstu programu innym, rozwiązanie takie nie jest zalecane (ze względu na brak kontroli zgodności typów, możliwość wy- stąpienia efektów ubocznych, etc.). Nie tylko wielokrotna implementacja funkcji wymaga dodatkowej pracy. Podobna sytu- acja występuje w przypadku implementacji zaawansowanych typów, takich jak konte- nery. Zarządzanie kolekcją elementów kontenera wymaga implementacji szeregu funkcji, C++. Szablony. Vademecum profesjonalisty, Helion 2003. 1 396 C++. Programowanie zorientowane obiektowo. Vademecum profesjonalisty w przypadku których istotny jest przede wszystkim typ elementu kolekcji. Gdyby nie możliwość wykorzystania specjalnych właściwości języka C++, wszystkie te funkcje musiałyby być implementowane za każdym razem, gdy pojawia się nowy typ elemen- tów kolekcji. Stos jest typowym przykładem, w którym pojawia się wiele implementacji służących zarządzaniu różnymi obiektami. Stos umożliwia przechowywanie i usuwanie elemen- tów konkretnego typu. Jeśli stosowalibyśmy poznane dotychczas konstrukcje języka C++, zmuszeni bylibyśmy implementować jego operacje osobno dla każdego typu ele- mentów, które mogą być umieszczone na stosie, ponieważ deklaracja stosu wymaga podania typu jego elementów. Te same operacje musielibyśmy więc implementować wielokrotnie, mimo, że rzeczywisty algorytm nie ulega zmianie. Nie tylko wymaga to dodatkowej pracy, ale może stać się także źródłem błęedów. Dlatego też w języku C++ wprowadzono szablony. Szablony reprezentują funkcje bądź klasy, które nie zostały zaimplementowane dla konkretnego typu, ponieważ typ ten zo- stanie dopiero zdefiniowany. Aby użyć szablonu funkcji lub klasy, programista aplika- cji musi określić typ, dla którego dany szablom zostanie zrealizowany. Wystarczy więc, że funkcja wyznaczająca większą z dwóch wartości zostanie zaimplementowana tylko raz — jako szablon. Podobnie kontenery, takie jak stosy, listy itp., wymagają tylko jed- nokrotnego zaimplementowania i przetestowania, a następnie mogą być wykorzystywane dla dowolnego typu elementów, który umożliwia przepreowadzanie odpowiednich operacji. Sposoby definiowania i posługiwania się szablonami zostaną wyjaśnione poniżej, naj- pierw dla funkcji na przykładzie funkcji OCZ , a następnie dla klas, na przykładzie stosu. 6GTOKPQNQIKC Terminologia związana z szablonami nie jest ściśle zdefiniowana. Na przykład funkcja, której typ został sparametryzowany, nazywana jest czasami szablonem funkcji, a innym razem funkcją szablonu. Ponieważ drugie z tych określeń jest nieco mylące (może okre- ślać szablon funkcji, ale także funkcję nie związaną z szablonem), powinno się raczej używać określenia szablon funkcji. Podobnie klasa sparametryzowana ze względu na typ powinna być nazywana szablonem klasy, a nie klasą szablonu. Proces, w którym przez podstawienie do szablonu wartości parametru powstaje zwykła klasa, funkcja lub funkcja składowa, nazywany jest tworzeniem instancji szablonu. Nie- stety, termin „tworzenie instancji” używany jest także w terminologii obiektowej dla określenia tworzenia obiektu danej klasy. Dlatego też znaczenie terminu „tworzenie in- stancji” zależy w przypadku języka C++ od kontekstu, we którym zostaje on użyty. 5CDNQP[HWPMELK Jak już wspomnieliśmy, szablony funkcji umożliwiają definiowanie grup funkcji, które mogą następnie zostać użyte dla różnych typów. Rozdział 7.  Szablony 397 W przeciwieństwie do działania makrodefinicji, działanie szablonów nie polega na me- chanicznym zastępowaniu tekstów. Semantyka funkcji zostaje sprawdzona przez kom- pilator, co pozwala zapobiec niepożądanym efektom ubocznym. Nie istnieje na przy- kład (tak jak w przypadku makrodefinicji) niebezpieczeństwo wielokrotnego zastąpienia parametru P , na skutek którego pojedyncza instrukcja inkrementacji staje się wielo- krotną inkrementacją.  GHKPKQYCPKGUCDNQPÎYHWPMELK Szablony funkcji definiowane są jak zwykłe funkcje, a parametryzowany typ poprzedza ich deklarację. Na przykład szablon funkcji wyznaczającej większą z dwóch wartości zostanie zadeklarowany w następujący sposób: VGORNCVGV[RGPCOG6 EQPUV6OCZ EQPUV6EQPUV6  W pierwszym wierszu zadeklarowany został parametr typu 6. Słowo kluczowe V[RGPCOG oznacza, że następujący po nim symbol reprezentuje typ. Słowo to zostało wprowadzone w języku C++ stosunkowo późno. Wcześniej używano zamiast niego słowa kluczowego ENCUU: VGORNCVGENCUU6 Pomiędzy słowami tymi nie ma różnic semantycznych. Użycie słowa kluczowego ENCUU nie wymaga, by parametryzowany typ był klasą. Używając obu słów kluczowych mo- żemy korzystać z dowolnych typów (podstawowych, klas etc.) pod warunkiem, że umożliwiają one wykonywanie operacji używanych przez szablon. W naszym przykła- dzie dla typu 6 musi być zdefiniowany operator porównania (), którego używa imple- mentacja szablonu funkcji OCZ . Zastosowanie symbolu 6 dla typu szablonu nie jest wymagane, ale w praktyce bywa często stosowane. W poniższej deklaracji symbol 6 używany jest w celu określenie typu funkcji oraz typu jej parametrów: VORNOCZJRR VGORNCVGV[RGPCOG6 EQPUV6OCZ EQPUV6CEQPUV6D ] TGVWTPC D!CD _ Instrukcje umieszczone w ciele szablonu nie różnią się niczym od instrukcji zwykłej implementacji funkcji. W powyższym przykładzie porównywane są dwie wartości typu 6 i zwracana jest większa z nich. Zastosowanie referencji stałych (EQPUV6) zapobiega tworzeniu kopii parametrów funkcji i wartości zwracanych przez funkcję (patrz podroz- dział 4.4). 398 C++. Programowanie zorientowane obiektowo. Vademecum profesjonalisty 9[YQđ[YCPKGUCDNQPÎYHWPMELK Szablonu funkcji używamy w taki sam sposób, jak zwykłej funkcji. Demonstruje to po- niższy program2: VORNOCZERR KPENWFGKQUVTGCO KPENWFGUVTKPI KPENWFGOCZJRR KPVOCKP ] KPVCDFYKGOKGPPGV[RWKPV UVFUVTKPIUVFYKGOKGPPGV[RWUVFUVTKPI  UVFEQWVOCZ CD UVFGPFNOCZ FNCFYÎEJYCTVQħEKECđMQYKV[EJ UVFEQWVOCZ UV UVFGPFNOCZ FNCFYÎEJđCēEWEJÎY _ Dopiero w momencie, gdy funkcja OCZ zostaje wywołana dla dwóch obiektów takiego samego typu, szablon staje się rzeczywistym kodem. Kompilator wykorzystuje definicję szablonu i tworzy jego instancję, zastępując typ 6 typem KPV lub UVFUVTKPI. W ten sposób tworzony jest rzeczywisty kod implementacji dla typu KPV bądź typu UVF UVTKPI. Szablony nie są więc kompilowane jako kod, który może działać z dowolnym typem danych, lecz jedynie wykorzystywane w celu wygenerowania kodu dla konkret- nego typu. Jeśli szablon OCZ zostanie wywołany dla siedmiu różnych typów, to skom- pilowanych zostanie siedem funkcji. Proces, w którym na podstawie szablonu generowany jest kod, który zostanie skompi- lowany, nazywany jest tworzeniem instancji lub, precyzyjniej (ze względu na zastoso- wanie określenia „tworzenie instancji” w terminologii obiektowej), tworzeniem instan- cji szablonu. Utworzenie instancji szablonu jest oczywiście możliwe tylko wtedy, gdy dla danego typu zdefiniowane są wszystkie operacje używane przez szablon. Aby możliwe było utwo- rzenie instancji szablonu OCZ dla typu UVFUVTKPI, w klasie UVFUVTKPI musi być zdefiniowany operator porównania (). Zauważmy, że w przeciwieństwie do działania makrodefinicji, działanie szablonów nie polega na zastępowaniu tekstów. Wywołanie OCZ Z    nie jest może szczególnie użyteczne, ale będzie działać poprawnie. Zwróci większą wartość jednego z przekazanych jej wyrażeń, a każde z wyrażeń wartościowane będzie tylko raz (czyli zmienna Z będzie inkrementowana jeden raz). 2 Wywołanie szablonu OCZ dla typu string zostało jawnie poprzedzone operato0rem globalnego zakresu, ponieważ w standardowej bibliotece zdefiniowana jes0t funkcja UVFOCZ . Ponieważ typ UVTKPI również znajduje się w przestrzeni nazw UVF, to funkcja OCZ nie poprzedzona operatorem zakresu zostałaby odnaleziona właśnie w tej przestrzeni (patrz „Wyszuki0wanie Koeniga”, str. 179). 2TCMV[EPGYUMCÎYMKFQV[EæEGWľ[YCPKCUCDNQPPÎY Rozdział 7.  Szablony 399 Koncepcja szablonów wykracza poza zwykły model kompilacji (konsolidacji), wyko- rzystujący odrębne jednostki translacji. Nie można na przykład umieścić szablonów w osobnym module i skompilować go, a następnie osobno skompilować aplikacji uży- wającej tych szablonów i skonsolidować oba uzyskane pliki wynikowe. Nie jest to możliwe, ponieważ typ, dla którego ma zostać użyty szablon, zostaje określony dopiero w momencie użycia szablonu. Istnieją różne sposoby rozwiązania tego problemu. Najprostszy i najbardziej uniwersalny polega na umieszczeniu całego kodu szablonu w pliku nagłówkowym. Dołączając na- stępnie zawartości pliku nagłówkowego do kodu aplikacji umożliwiamy generację i kompilację kodu dla konkretnych typów. Nieprzypadkowo więc definicja szablonu OCZ z poprzedniego przykładu została umieszczona w pliku nagłówkowym. Należy przy tym zauważyć, że słowo kluczowe KPNKPG (patrz podrozdział 4.3.3) nie musi być zastosowane. W przypadku szablonów dopuszczalne jest istnienie wielu definicji w różnych jednostkach translacji. Jeśli jednak preferujemy rozwijanie szablonu funkcji w miejscu jego wywołania, powinniśmy zasy- gnalizować to kompilatorowi właśnie za pomocą słowa keluczowego KPNKPG. Więcej zagadnień związanych z posługiwaniem się szablonami zostanie omówionych w podrozdziale 7.6. 5CDNQP[KCWVQOCV[EPCMQPYGTULCV[RW Podczas tworzenia instancji szablonu nie jest brana pod uwagę automatyczna konwersja typu. Jeśli szablon posiada wiele parametrów typu 6, przekazane mu argumenty muszą być tego samego typu. Wywołanie szablonu OCZ dla obiektów różnych typów nie jest więc możliwe: VGORNCVGV[RGPCOG6 EQPUV6OCZ EQPUV6EQPUV QDCRCTCOGVT[OCLæV[R6  KPVK NQPIN  OCZ KN $Đä OKGPPGKQTCNRQUKCFCLæTÎľPGV[R[ ,CYPCMYCNKHKMCELC Wywołując szablon możemy zastosować jawną kwalifikację typu, dla którego zostanie on użyty: OCZNQPI KN Y[YQđCPKGUCDNQPWOCZ FNCV[RWNQPI W tym przypadku tworzona jest instancja szablonu funkcji OCZ dla typu NQPI jako pa- rametru 6 szablonu. Następnie, podobnie jak w przypadku zwykłych funkcji, kompilator sprawdza, czy przekazane parametry mogą być użyte jako wartości typu NQPI, co jest możliwe w naszym przykładzie ze względu na istnienie domyślnej konwersji typu KPV do typu NQPI. 400 C++. Programowanie zorientowane obiektowo. Vademecum profesjonalisty 5CDNQP[QYKGNWRCTCOGVTCEJ Szablon może zostać zdefiniowany także dla różnych teypów: VGORNCVGV[RGPCOG6V[RGPCOG6 KPNKPG6OCZ EQPUV6EQPUV6 ] TGVWTPCD!DC _  KPVK NQPIN  OCZ KN YTCECYCTVQħèV[RWKPV Problemem w tym przypadku jest typ wartości zwracanej przez funkcję, ponieważ w momencie definiowania szablonu nie wiemy, który z parametrów zostanie zwrócony. Dodatkowo, jeśli zwrócony będzie drugi parametr, dla wartości zwracanej utworzony zostanie lokalny obiekt tymczasowy, ponieważ posiada ona inny typ. Obiekt tymczaso- wy nie może zostać zwrócony przez referencję, wobec czego typ zwracany przez sza- blon został zmieniony z EQPUV6 na 6. W takim przypadku lepszym rozwiązaniem jest możliwoeść jawnej kwalifikacji. 2TGEKæľCPKGUCDNQPÎY Szablony mogą być przeciążane dla pewnych typów. W ten sposób ogólna implementa- cja szablonu może zostać zastąpiona inną implementacją dla konkretnych typów. Roz- wiązanie takie posiada szereg zalet:  Szablony funkcji mogą zostać zdefiniowane dla dodatkoweych typów oraz ich kombinacji (na przykład może zostać zdefiniowana funkceja OCZ o parametrach typu HNQCV i 22$QQM(TCEVKQP).  Implementacje mogą zostać zoptymalizowane dla konkretenych typów.  Typy, dla których implementacja szablonu nie jest odepowiednia, mogą zostać właściwie obsłużone. Wywołanie szablonu OCZ dla C-łańcuchów (typ EQPUVEJCT ) spowoduje błąd: EQPUVEJCT U EQPUVEJCT U  EQPUVEJCT OCZUVTKPIOCZ UU $Đä RQTÎYPWLGCFTGU[ Implementacja szablonu porówna w tym przypadku adresy C-łańcuchów zamiast ich zawartości (patrz podrozdział 3.7.3). Problem ten możemy rozwiązać poprzez przeciążenie szeablonu dla C-łańcuchów: KPNKPGEQPUVEJCT OCZ EQPUVEJCT CEQPUVEJCT D ] TGVWTPUVFUVTEOR CD  !CD _ Rozdział 7.  Szablony 401 Przeciążenie szablonu może także dotyczyć wskaźników. Możemy w ten sposób sprawić, że jeśli szablon OCZ zostanie wywołany dla wskaźników, porównane zostaną wska- zywane przez nie obiekty, a nie ich adresy. Na przykeład: VGORNCVGV[RGPCOG6 6 EQPUVOCZ 6 EQPUVC6 EQPUVD ] TGVWTP C  D!CD _ Zwróćmy uwagę, że jeśli wskaźnik ma zostać przekazany jako stała referencja, słowo kluczowe EQPUV musi zostać umieszczone po znaku gwiazdki. W przeciwnym razie za- deklarowany zostanie wskaźnik do stałej (patrz takżee podrozdział 4.4.6). Przeciążając szablony funkcji powinniśmy wprowadzać jedynie niezbędne modyfikacje, takie jak zmiany liczby parametrów czy jawne ich określenie. W przeciwnym razie wprowadzone zmiany mogą stać się powodem powstawania nieoczekiwanych efektów. Dlatego też w naszym przykładzie argumenty wszystkich przeciążonych implementacji powinny być przekazywane poprzez stałe referencje: VORNOCZERR KPENWFGKQUVTGCO KPENWFGEUVTKPI YTCECYKúMUæFYÎEJYCTVQħEKFQYQNPGIQV[RW VGORNCVGV[RGPCOG6 KPNKPGEQPUV6OCZ EQPUV6CEQPUV6D ] UVFEQWVOCZ FNC6UVFGPFN TGVWTPCD!DC _ FNCFYÎEJYUMCļPKMÎY VGORNCVGV[RGPCOG6 KPNKPG6 EQPUVOCZ 6 EQPUVC6 EQPUVD ] UVFEQWVOCZ FNC6 UVFGPFN TGVWTP C D!DC _ FNCFYÎEJ đCēEWEJÎY KPNKPGEQPUVEJCT EQPUVOCZ EQPUVEJCT EQPUVC EQPUVEJCT EQPUVD P ] UVFEQWVOCZ FNCEJCT UVFGPFN TGVWTPUVFUVTEOR CD !DC _ Wykonanie przedstawionego poniżej programu: VORNOCZERR KPENWFGKQUVTGCO KPENWFGUVTKPI KPENWFGOCZJRR KPVOCKP 402 C++. Programowanie zorientowane obiektowo. Vademecum profesjonalisty ] KPVCFYKGOKGPPGV[RWKPV KPVD UVFEQWVOCZ CD UVFGPFNOCZ FNCFYÎEJCTIWOGPVÎYV[RWKPV UVFUVTKPIUJGNNQFYCđCēEWEJ[ UVFUVTKPIVJQNNC UVFEQWVOCZ UV UVFGPFNOCZ FNCFYÎEJCTIWOGPVÎYV[RWUVTKPI KPV RDFYCYUMCļPKMK KPV RC UVFEQWV OCZ RR UVFGPFNOCZ FNCFYÎEJYUMCļPKMÎY EQPUVEJCT UJGNNQFYC đCēEWEJ[ EQPUVEJCT UQVVQ UVFEQWVOCZ UU UVFGPFNOCZ FNCFYÎEJ đCēEWEJÎY _ spowoduje wyświetlenie następujących napisów: OCZ FNC6  OCZ FNC6 JQNNC OCZ FNC6  OCZ FNCEJCT QVVQ  OKGPPGNQMCNPG Szablony funkcji mogą posiadać zmienne lokalne typu będącego parametrem szablonu. Na przykład szablon funkcji zamieniającej wartości dwóch parametrów może zostać zaimplementowany w następujący sposób (proszę porównać z implementacją funkcji UYCR przedstawioną na stronie 185). VGORNCVGV[RGPCOG6 XQKFUYCR 6C6D ] 6VOR C  CD DVOR _ Zmienne lokalne mogą być również statyczne. W takim przypadku tworzone są zmien- ne statyczne wszystkich typów, dla których wywoływaeny jest szablon funkcji. 2QFUWOQYCPKG  Szablony są schematami kodu kompilowanego po wybraneiu określonego typu danych.  Tworzenie kodu w języku C++ na podstawie szablonu nazyewamy tworzeniem instancji szablonu. Rozdział 7.  Szablony 403  Szablony mogą posiadać wiele parametrów.  Szablony funkcji mogą być przeciążane. 5CDNQP[MNCU W takim sam sposób, jak parametryzowane są typy funkcji, mogą również być parame- tryzowane typy w klasach. Możliwość taka jest szczególnie przydatna w przypadku kontenerów używanych do zarządzania obiektami pewnego typu. Szablony klas możemy wykorzystać do implementacji kontenerów, dla których typ elementów nie jest jeszcze zna- ny. W terminologii obiektowej szablony klas nazywanee są klasami parametryzowanymi. Implementacja szablonów klas zostanie omówiona na przykładzie klasy stosu. Imple- mentacja ta wykorzystywać będzie szablon klasy XGEVQT , dostępny w bibliotece stan- dardowej (patrz podrozdziały 3.5.1 i 9.1.1). +ORNGOGPVCELCUCDNQPWMNCU[5VCEM Podobnie, jak w przypadku szablonów funkcji, także deklaracja i definicja szablonu klasy umieszczana jest zwykle w pliku nagłówkowym. Zawartość pliku nagłówkowego klasy 5VCEM jest następująca: VORNUVCEMJRR KPENWFGXGEVQT KPENWFGUVFGZEGRV  2QEæVGMRTGUVTGPKPCY 22$QQM PCOGURCEG 22$QQM] VGORNCVGV[RGPCOG6 ENCUU5VCEM] RTKXCVG UVFXGEVQT6 GNGOUGNGOGPV[ RWDNKE 5VCEM MQPUVTWMVQT XQKFRWUJ EQPUV6 WOKGUECPQY[GNGOGPVPCUE[EKG XQKFRQR WUWYCGNGOGPVGUE[VW 6VQR EQPUVYTCECGNGOGPVPCLFWLæE[UKúPCUE[EKG _ MQPUVTWMVQT VGORNCVGV[RGPCOG6 5VCEM6 5VCEM ] PKGY[MQPWLGľCFP[EJKPUVTWMELK _ VGORNCVGV[RGPCOG6 XQKF5VCEM6 RWUJ EQPUV6GNGO 404 C++. Programowanie zorientowane obiektowo. Vademecum profesjonalisty ] GNGOURWUJADCEM GNGO WOKGUECMQRKúPCUE[EKGUVQUW _ VGORNCVGV[RGPCOG6 XQKF5VCEM6 RQR ] KH GNGOUGORV[ ] VJTQYUVFQWVAQHATCPIG 5VCEM RQR RWUV[UVQPU  _ GNGOURQRADCEM WUWYCGNGOGPVGUE[VWUVQUW _ VGORNCVGV[RGPCOG6 65VCEM6 VQR EQPUV ] KH GNGOUGORV[ ] VJTQYUVFQWVAQHATCPIG 5VCEM VQR RWUV[UVQPU  _ TGVWTPGNGOUDCEM YTCECMQRKúGNGOGPVWPCLFWLæEGIQUKúPCUE[EKG _ _ -QPKGERTGUVTGPKPCY 22$QQM GMNCTCELCUCDNQPWMNCU[ Podobnie, jak w przypadku szablonu funkcji, deklaracja szablonu klasy poprzedzona jest określeniem parametru typu 6 (parametrów szablonu może być oczywiście więcej): VGORNCVGV[RGPCOG6 ENCUU5VCEM]  _ Zamiast słowa kluczowego V[RGPCOG może być też użyte słowo ENCUU: VGORNCVGENCUU6 ENCUU5VCEM]  _ Wewnątrz klasy typ 6 może być używany w deklaracjach składowych klasy i funkcji składowych w taki sam sposób, jak każdy zwykły typ. W naszym przykładzie elementy stosu zarządzane są wewnątrz klasy za pomocą wektora o elementach typu 6 (szablon jest zaimplementowany z użyciem innego szablonu), funkcja RWUJ używa referencji stałej typu 6 jako parametru, a funkcja VQR zwraca obiekt typu 6. Klasa stosu posiada typ 5VCEM6 , gdzie 6 jest parametrem szablonu. Typ ten musi zo- stać użyty za każdym razem, gdy posługujemy się klasą stosu. Nazwy 5VCEM używamy jedynie podczas definiowania klasy oraz jej konstruektorów i destruktorów: ENCUU5VCEM]  _ Rozdział 7.  Szablony 405 Poniższy przykład przedstawia sposób użycia szablonu klasy jako typu parametrów funkcji lub wartości przez nie zwracanych (w deklaracjach konstruktora kopiującego i operatora przypisania)3: VGORNCVGV[RGPCOG6 ENCUU5VCEM]  5VCEM EQPUV5VCEM6  MQPUVTWMVQTMQRKWLæE[ 5VCEM6 QRGTCVQT EQPUV5VCEM6  QRGTCVQTRT[RKUCPKC  _ +ORNGOGPVCELCHWPMELKUMđCFQY[EJ Definiując funkcję składową szablonu klasy musimy określić jej przynależność do sza- blonu. Przykład implementacji funkcji RWUJ pokazuje, że nazwa funkcji musi zostać poprzedzona pełnym typem szablonu 5VCEM6 : VGORNCVGV[RGPCOG6 XQKF5VCEM6 RWUJ EQPUV6GNGO ] GNGOURWUJADCEM GNGO WOKGUECMQRKúPCUVQUKG _ Implem
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

C++. Programowanie zorientowane obiektowo. Vademecum profesjonalisty
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ą: