.:$$:.

• Efektywne zarządzanie pamięcią
• Obsługa błędów
• Biblioteki i wzorce projektowe

Język C++ od dawna cieszy się zasłużoną popularnością wśród twórców oprogramowania. Jednak często nawet najbardziej doświadczeni programiści nie wykorzystują wszystkich jego możliwości. W opracowaniach dotyczących tego języka najczęściej omawiana jest składnia i elementy języka, a znacznie rzadziej -- jego praktyczne zastosowania. Brak odniesień do praktyki powoduje nieznajomość wielu niezwykle przydatnych i ułatwiających pracę aspektów C++ i nadmierne eksploatowanie prostych, książkowych konstrukcji.

Książka "C++. Zaawansowane programowanie" to przegląd metod programowania nie omawianych w większości publikacji. Ten przeznaczony dla średnio zaawansowanych programistów podręcznik przedstawia zasady stosowania C++ do rozwiązywania prawdziwych problemów. Opisuje nieznane możliwości znacznie przyspieszające i usprawniające pracę, sposoby tworzenia przenośnego kodu oraz testowania oprogramowania. Książka zawiera również omówienie biblioteki standardowej C++ oraz wzorców projektowych.

• Zasady tworzenia projektów w C++
• Projektowanie obiektowe
• Korzystanie z biblioteki standardowej C++
• Tworzenie kodu przeznaczonego do wielokrotnego zastosowania
• Styl kodowania
• Zarządzanie pamięcią
• Procedury obsługi wyjątków
• Przeciążanie operatorów
• Tworzenie aplikacji wieloplatformowych
• Testowanie kodu i usuwanie błędów
• Programowanie rozproszone
• Stosowanie wzorców projektowych

• Podstawy C++ (25)
• Teraz obowiązkowo Hello, World (26)
• Przestrzenie nazw (28)
• Zmienne (30)
• Operatory (32)
• Typy danych (34)
• Wyrażenia warunkowe (36)
• Pętle (38)
• Tablice (40)
• Funkcje (41)
• To był elementarz (42)
• C++ z bliska (42)
• Wskaźniki i pamięć alokowana dynamicznie (42)
• Łańcuchy znakowe w C++ (45)
• Referencje (47)
• Wyjątki (48)
• Wiele zastosowań słowa kluczowego const (49)
• C++ jako język obiektowy (50)
• Deklarowanie klasy (51)
• Nasz pierwszy praktyczny program C++ (53)
• System obsługi kadrowej (53)
• Klasa Employee (54)
• Klasa Database (58)
• Interfejs użytkownika (62)
• Udoskonalanie programu (65)
• Podsumowanie (65)

• Czym jest projekt programu? (68)
• Dlaczego projekt programu jest tak ważny? (68)
• Co jest szczególnego w projektach C++? (70)
• Dwie zasady tworzenia projektów w C++ (71)
• Abstrakcja (71)
• Wielokrotne użycie (73)
• Projektowanie programu szachowego (75)
• Wymagania (75)
• Kolejne etapy projektowania (76)
• Podsumowanie (80)

• Obiektowe spojrzenie na świat (83)
• Czy myślę proceduralnie? (83)
• Filozofia obiektowa (84)
• W świecie obiektów (87)
• Powiązania obiektów (89)
• Abstrakcja (99)
• Podsumowanie (102)

• Wielokrotne użycie kodu (103)
• Uwaga na temat terminologii (104)
• Podejmowanie decyzji, czy ponownie wykorzystać kod (105)
• Strategie wielokrotnego użycia kodu (107)
• Korzystanie z obcych aplikacji (112)
• Biblioteki open-source (113)
• Standardowa biblioteka C++ (114)
• Projektowanie z użyciem wzorców i technik (127)
• Techniki projektowe (128)
• Wzorce projektowe (129)
• Podsumowanie (130)

• Filozofia wielokrotnego użycia (132)
• Jak projektować kod wielokrotnego użycia (132)
• Użycie abstrakcji (133)
• Struktura kodu wielokrotnego użycia (134)
• Projektowanie interfejsów (139)
• Łączenie ogólności i prostoty użycia (145)
• Podsumowanie (146)

• Potrzeba stosowania procesu (147)
• Modele cyklu życia oprogramowania (149)
• Model etapowy i kaskadowy (149)
• Metoda spirali (152)
• Rational Unified Process (154)
• Metodyki inżynierii oprogramowania (155)
• Programowanie ekstremalne (XP) (156)
• Sąd nad oprogramowaniem (160)
• Tworzenie własnego procesu i metodyki (161)
• Bądź otwarty na nowe pomysły (161)
• Dziel się pomysłami (161)
• Zorientuj się, co działa, a co nie (162)
• Nie bądź renegatem (162)
• Podsumowanie (162)

• Piękny wygląd (165)
• Myślenie o przyszłości (165)
• Zachowanie porządku (166)
• Elementy dobrego stylu (166)
• Dokumentowanie kodu (166)
• Po co pisać komentarze (166)
• Style komentowania (169)
• Komentarze w tej książce (174)
• Dekompozycja (174)
• Dekompozycja przez refaktoring (174)
• Dekompozycja na etapie projektu (176)
• Dekompozycja w tej książce (176)
• Nazewnictwo (176)
• Dobór właściwej nazwy (177)
• Konwencje nazewnicze (177)
• Elementy języka a styl (180)
• Stałe (180)
• Korzystanie ze zmiennych const (180)
• Użycie referencji zamiast wskaźników (180)
• Wyjątki użytkownika (181)
• Formatowanie (181)
• Rozmieszczenie nawiasów klamrowych (182)
• Spacje i nawiasy (183)
• Spacje i tabulatory (183)
• Wyzwania związane ze stylem (183)
• Podsumowanie (184)

• Wprowadzenie do przykładu arkusza kalkulacyjnego (185)
• Pisanie klas (186)
• Definicje klasy (186)
• Definiowanie metod (188)
• Użycie obiektów (192)
• Cykl życia obiektów (193)
• Tworzenie obiektu (193)
• Usuwanie obiektu (204)
• Przypisania do obiektów (206)
• Odróżnianie kopiowania od przypisania (208)
• Podsumowanie (210)

• Dynamiczna alokacja pamięci w obiektach (211)
• Klasa Spreadsheet (212)
• Zwalnianie pamięci w destruktorach (213)
• Obsługa kopiowania i przypisania (214)
• Różne rodzaje pól w klasach (221)
• Pola statyczne (221)
• Pola stałe (223)
• Pola będące referencjami (225)
• Pola będące stałymi referencjami (226)
• Jeszcze o metodach (226)
• Metody statyczne (226)
• Metody stałe (227)
• Przeciążanie metod (229)
• Parametry domyślne (230)
• Metody inline (231)
• Klasy zagnieżdżone (233)
• Zaprzyjaźnienie (235)
• Przeciążanie operatorów (236)
• Implementacja dodawania (236)
• Przeciążanie operatorów arytmetycznych (240)
• Przeciążanie operatorów porównania (242)
• Tworzenie typów z przeciążaniem operatorów (244)
• Wskaźniki pól i metod (244)
• Tworzenie klas abstrakcyjnych (245)
• Użycie klas interfejsu i implementacji (246)
• Podsumowanie (249)

• Klasy i dziedziczenie (251)
• Rozszerzanie klas (252)
• Nadpisywanie metod (255)
• Dziedziczenie a wielokrotne użycie kodu (258)
• Klasa WeatherPrediction (258)
• Nowe możliwości w podklasie (259)
• Inne możliwości w podklasie (261)
• Szacunek dla rodziców (262)
• Konstruktory rodziców (262)
• Destruktory rodziców (264)
• Odwołania do danych rodziców (266)
• Rzutowanie w górę i w dół (267)
• Dziedziczenie i polimorfizm (268)
• Powrót do arkusza kalkulacyjnego (269)
• Polimorficzna komórka arkusza (269)
• Klasa bazowa komórki arkusza (270)
• Poszczególne podklasy (272)
• Polimorfizm dla zaawansowanych (274)
• Uwagi na przyszłość (275)
• Dziedziczenie wielokrotne (276)
• Dziedziczenie po wielu klasach (277)
• Kolizje nazw i niejednoznaczne klasy bazowe (278)
• Ciekawostki i tajemnice dziedziczenia (281)
• Zmiana charakterystyki nadpisanej metody (281)
• Przypadki szczególne nadpisywania metod (285)
• Konstruktory kopiujące i operator równości (291)
• Prawda o wirtualności (293)
• Typy podczas działania programu (296)
• Dziedziczenie niepubliczne (297)
• Wirtualne klasy bazowe (298)
• Podsumowanie (299)

• Szablony w skrócie (302)
• Szablony klas (303)
• Pisanie szablonu klasy (303)
• Jak kompilator przetwarza szablony (311)
• Rozdzielanie kodu szablonu między pliki (312)
• Parametry szablonów (313)
• Szablony metod (316)
• Specjalizacja klas szablonów (321)
• Podklasy szablonów klas (324)
• Dziedziczenie a specjalizacja (325)
• Szablony funkcji (326)
• Specjalizacja szablonów funkcji (327)
• Przeciążanie szablonów funkcji (327)
• Szablony funkcji zaprzyjaźnionych szablonów klas (328)
• Szablony: zagadnienia zaawansowane (330)
• Więcej o parametrach szablonów (330)
• Częściowa specjalizacja szablonów klas (338)
• Przeciążanie jako symulacja specjalizacji częściowej funkcji (344)
• Szablony rekurencyjnie (345)
• Podsumowanie (353)

• Referencje (355)
• Zmienne referencyjne (356)
• Referencje do pól (358)
• Parametry referencyjne (358)
• Zwracanie wartości przez referencję (359)
• Wybór między referencjami a wskaźnikami (360)
• Zamieszanie ze słowami kluczowymi (362)
• Słowo kluczowe const (362)
• Słowo kluczowe static (365)
• Porządek inicjalizacji zmiennych nielokalnych (369)
• Typy i rzutowanie (369)
• typedef (370)
• Rzutowanie (371)
• Zasięg (375)
• Pliki nagłówkowe (376)
• Narzędzia C (377)
• Listy parametrów o zmiennej długości (378)
• Makra preprocesora (380)
• Podsumowanie (381)

• Użycie pamięci dynamicznej (385)
• Jak sobie wyobrazić pamięć (386)
• Alokacja i zwalnianie (387)
• Tablice (389)
• Użycie wskaźników (396)
• Dualność tablic i wskaźników (398)
• Tablice są wskaźnikami! (398)
• Nie wszystkie wskaźniki są tablicami! (399)
• Łańcuchy dynamiczne (400)
• Łańcuchy w stylu C (400)
• Literały łańcuchowe (402)
• Klasa C++ string (402)
• Niskopoziomowe operacje na pamięci (404)
• Arytmetyka wskaźników (405)
• Specjalne zarządzanie pamięcią (405)
• Odśmiecanie pamięci (406)
• Pule obiektów (407)
• Wskaźniki funkcji (407)
• Typowe błędy związane z zarządzaniem pamięcią (409)
• Brak pamięci na łańcuchy (409)
• Wycieki pamięci (410)
• Dwukrotne usuwanie i błędne wskaźniki (413)
• Dostęp do pamięci spoza zakresu (414)
• Podsumowanie (414)

• Użycie strumieni (416)
• Czym jest strumień (416)
• Źródła i przeznaczenie strumieni (416)
• Strumienie wyjściowe (417)
• Strumienie wejściowe (421)
• Wejście i wyjście realizowane za pomocą obiektów (426)
• Strumienie łańcuchowe (428)
• Strumienie plikowe (429)
• Poruszanie się za pomocą seek() i tell() (430)
• Wiązanie strumieni (432)
• Wejście-wyjście dwukierunkowe (433)
• Internacjonalizacja (435)
• Znaki rozszerzone (435)
• Zestawy znaków inne niż zachodnie (436)
• Ustawienia lokalne i fazy (436)
• Podsumowanie (438)

• Błędy i wyjątki (440)
• Czym są wyjątki (440)
• Zalety wyjątków języka C++ (441)
• Wady wyjątków języka C++ (442)
• Zalecenia (442)
• Mechanika wyjątków (443)
• Zgłaszanie i wyłapywanie wyjątków (443)
• Typy wyjątków (445)
• Zgłaszanie i wyłapywanie wielu wyjątków (447)
• Niewyłapane wyjątki (449)
• Lista zgłaszanych wyjątków (451)
• Wyjątki i polimorfizm (455)
• Hierarchia standardowych wyjątków (455)
• Przechwytywanie wyjątków w hierarchii klas (456)
• Pisanie własnych klas wyjątków (458)
• Odwijanie stosu i zwalnianie zasobów (461)
• Złap wyjątek, dokonaj zwolnienia zasobu i ponownie zgłoś wyjątek (462)
• Wykorzystanie inteligentnych wskaźników (463)
• Typowe zagadnienia dotyczące obsługi błędów (463)
• Błędy alokacji pamięci (463)
• Błędy w konstruktorach (466)
• Błędy w destruktorze (467)
• Połączenie wszystkiego razem (468)
• Podsumowanie (470)

• Omówienie przeciążania operatorów (474)
• Powody przeciążania operatorów (474)
• Ograniczenia przeciążania operatorów (474)
• Wybór przeciążania operatorów (475)
• Operatory, których nie należy przeciążać (478)
• Podsumowanie operatorów z możliwością przeciążania (478)
• Przeciążanie operatorów arytmetycznych (481)
• Przeciążanie jednoargumentowego operatora plus i minus (481)
• Przeciążanie inkrementacji i dekrementacji (482)
• Przeciążanie operatorów bitowych i operatorów logicznych dwuargumentowych (484)
• Przeciążanie operatorów wstawiania i wydobywania (484)
• Przeciążanie operatora indeksu tablicy (486)
• Zapewnienie dostępu tylko do odczytu dla operatora operator[] (489)
• Indeksy niebędące liczbami całkowitymi (490)
• Przeciążenie operatora wywołania funkcji (491)
• Przeciążanie operatorów dereferencji (493)
• Implementacja operatora operator* (494)
• Implementacja operatora operator-> (495)
• Co oznacza operator->*? (496)
• Pisanie operatorów konwersji (496)
• Problemy niejednoznaczności operatorów konwersji (498)
• Konwersje dla wyrażeń logicznych (498)
• Przeciążanie operatorów alokacji i zwalniania pamięci (500)
• Jak tak naprawdę działają operatory new i delete (501)
• Przeciążanie operatorów new i delete (502)
• Przeciążanie operatorów new i delete z dodatkowymi parametrami (505)
• Podsumowanie (507)

• Omówienie wydajności i efektywności (509)
• Dwa podejścia do efektywności (510)
• Dwa rodzaje programów (510)
• Czy C++ to nieefektywny język programowania? (510)
• Efektywność na poziomie języka (511)
• Wydajna obsługa obiektów (512)
• Nie nadużywaj kosztownych elementów języka (515)
• Użycie metod i funkcji rozwijanych w miejscu wywołania (516)
• Efektywność na poziomie projektu (517)
• Stosuj buforowanie podręczne, jeśli tylko to możliwe (517)
• Pule obiektów (518)
• Wykorzystanie puli wątków (523)
• Profilowanie (524)
• Profilowanie przykładu za pomocą gprof (524)
• Podsumowanie (533)

• Tworzenie aplikacji wieloplatformowych (536)
• Kwestie architektury (536)
• Kwestie implementacji (539)
• Elementy specyficzne dla platformy programowo-sprzętowej (540)
• Aplikacje wielojęzykowe (541)
• Mieszanie języków C i C++ (541)
• Zmieszane paradygmaty (542)
• Konsolidacja kodu języka C (545)
• Łączenie Javy i C++ dzięki JNI (546)
• Mieszanie C++ z Perlem i skryptami powłoki (549)
• Mieszanie C++ z kodem w języku asemblera (552)
• Podsumowanie (552)

• Kontrola jakości (554)
• Kto jest odpowiedzialny za testowanie? (554)
• Cykl życia błędu (554)
• Narzędzia do śledzenia błędów (555)
• Testy jednostkowe (556)
• Metody testowania jednostkowego (557)
• Proces testowania jednostkowego (558)
• Testy jednostkowe w praktyce (562)
• Testowanie wyższego poziomu (570)
• Testy integracyjne (571)
• Testy systemowe (572)
• Testy regresyjne (573)
• Wskazówki na temat testowania (574)
• Podsumowanie (574)

• Podstawowe zasady debugowania (575)
• Taksonomia błędów (576)
• Unikanie błędów (576)
• Przewidywanie błędów (577)
• Rejestrowanie błędów (577)
• Rejestrowanie śladu (578)
• Asercje (589)
• Techniki debugowania (590)
• Reprodukcja błędów (591)
• Debugowanie błędów powtarzalnych (592)
• Debugowanie błędów niemożliwych do powtórzenia (592)
• Debugowanie błędów pamięci (593)
• Debugowanie programów wielowątkowych (597)
• Przykład debugowania: cytowanie artykułów (598)
• Wnioski z przykładu ArticleCitations (609)
• Podsumowanie (609)

• Przegląd kontenerów (612)
• Wymagania co do elementów (612)
• Wyjątki i kontrola błędów (614)
• Iteratory (614)
• Kontenery sekwencyjne (616)
• Wektor (616)
• Specjalizowana implementacja vector<bool> (634)
• Kontener deque (635)
• Kontener list (636)
• Adaptery kontenerów (640)
• Adapter queue (640)
• Adapter priority_queue (643)
• Adapter stack (646)
• Kontenery asocjacyjne (647)
• Klasa narzędziowa pair (647)
• Kontener map (648)
• Kontener multimap (657)
• Kontener set (661)
• Kontener multiset (663)
• Inne kontenery (663)
• Tablice jako kontenery STL (663)
• string jako kontener STL (664)
• Strumienie jako kontenery STL (665)
• Kontener bitset (665)
• Podsumowanie (670)

• Przegląd algorytmów (674)
• Algorytmy find() oraz find_if() (674)
• Algorytm accumulate() (677)
• Obiekty funkcyjne (678)
• Obiekty funkcji arytmetycznych (678)
• Obiekty funkcji porównań (679)
• Obiekty funkcji logicznych (680)
• Adaptery obiektów funkcyjnych (681)
• Tworzenie własnych obiektów funkcyjnych (685)
• Szczegóły budowy algorytmów (686)
• Algorytmy użytkowe (686)
• Algorytmy niemodyfikujące (687)
• Algorytmy modyfikujące (693)
• Algorytmy sortujące (698)
• Algorytmy dla zbiorów (701)
• Przykład użycia algorytmów i obiektów funkcyjnych: kontrola list wyborców (702)
• Problem kontroli rejestrów wyborców (703)
• Funkcja auditVoterRolls() (703)
• Funkcja getDuplicates() (704)
• Funktor RemoveNames (705)
• Funktor NameInList (706)
• Testowanie funkcji auditVoterRolls() (707)
• Podsumowanie (708)

• Alokatory (710)
• Adaptery iteratorów (710)
• Iteratory działające wstecz (710)
• Iteratory strumienia (712)
• Iteratory wstawiające (712)
• Rozszerzanie STL (714)
• Po co rozszerzamy STL? (715)
• Tworzenie algorytmów STL (715)
• Tworzenie kontenera STL (717)
• Podsumowanie (747)

• Zalety programowania rozproszonego (749)
• Rozpraszanie w celu zwiększenia skalowalności (749)
• Rozpraszanie w celu zwiększenia niezawodności (750)
• Rozpraszanie w celu centralizacji (750)
• Rozpraszanie treści (751)
• Przetwarzanie rozproszone a sieciowe (751)
• Obiekty rozproszone (752)
• Serializacja i szeregowanie (752)
• Zdalne wywoływanie procedur (756)
• CORBA (758)
• Język definicji interfejsu (758)
• Implementacja klasy (761)
• Wykorzystanie obiektów (762)
• XML (766)
• Szybki kurs XML (766)
• XML jako technologia obiektów rozproszonych (768)
• Generowanie i analizowanie XML w C++ (769)
• Kontrola poprawności XML (777)
• Tworzenie obiektów rozproszonych z użyciem XML (779)
• SOAP (ang. Simple Object Access Protocol) (782)
• Podsumowanie (784)

• Nigdy nie pamiętam, jak... (786)
• ...utworzyć klasę (786)
• ...dziedziczyć po istniejącej klasie (787)
• ...zgłosić i przechwycić wyjątek (788)
• ...odczytać z pliku (789)
• ...zapisać do pliku (789)
• ...utworzyć szablon klasy (790)
• Musi istnieć lepszy sposób (792)
• Inteligentne wskaźniki ze zliczaniem referencji (792)
• Podwójne rozsyłanie (797)
• Klasy domieszkowe (803)
• Biblioteki obiektowe (806)
• Wykorzystywanie bibliotek (806)
• Paradygmat model-widok-kontroler (807)
• Podsumowanie (808)

• Wzorzec singleton (810)
• Przykład: mechanizm dziennika (810)
• Implementacja klasy singleton (810)
• Wykorzystanie klasy singleton (815)
• Wzorzec factory (816)
• Przykład: symulacja fabryki samochodów (816)
• Implementacja klasy factory (818)
• Wykorzystanie wzorca factory (820)
• Inne zastosowania wzorca factory (822)
• Wzorzec proxy (822)
• Przykład: ukrywanie problemów z połączeniem sieciowym (822)
• Implementacja klasy proxy (823)
• Wykorzystanie klasy proxy (824)
• Wzorzec adapter (824)
• Przykład: adaptacja biblioteki XML (824)
• Implementacja adaptera (825)
• Wykorzystanie klasy adaptera (828)
• Wzorzec decorator (829)
• Przykład: definiowanie stylów na stronach WWW (829)
• Implementacja klasy decorator (830)
• Wykorzystanie klasy decorator (831)
• Wzorzec chain of responsibility (832)
• Przykład: obsługa zdarzeń (833)
• Implementacja łańcucha odpowiedzialności (833)
• Wykorzystanie łańcucha odpowiedzialności (834)
• Wzorzec observer (834)
• Przykład: obsługa zdarzeń (835)
• Implementacja wzorca observer (835)
• Wykorzystanie wzorca observer (836)
• Podsumowanie (837)

• Rozdział 1. "Skrócony kurs C++" (841)
• Rozdział 2. "Tworzenie profesjonalnych programów w C++" (842)
• Rozdział 3. "Projektowanie obiektowe" (843)
• Rozdział 4. "Użycie bibliotek i wzorców" (844)
• Rozdział 5. "Projektowanie z myślą o ponownym użyciu" (845)
• Rozdział 6. "Użycie metod inżynierii oprogramowania" (846)
• Rozdział 7. "Styl kodowania" (847)
• Rozdziały 8. i 9. Klasy i obiekty (848)
• Rozdział 10. "Przygoda z dziedziczeniem" (851)
• Rozdział 11. "Szablony i kod ogólny" (851)
• Rozdział 12. "Dziwactwa C++" (852)
• Rozdział 13. "Skuteczne zarządzanie pamięcią" (853)
• Rozdział 14. "Wejście-wyjście w C++. Pożegnanie z mitami" (854)
• Rozdział 15. "Obsługa błędów" (855)
• Rozdział 16. "Przeciążanie operatorów języka C++" (856)
• Rozdział 17. "Pisanie wydajnego kodu" (856)
• Rozdział 18. "Tworzenie aplikacji wieloplatformowych i wielojęzykowych" (857)
• Rozdział 19. "Podstawy testowania" (858)
• Rozdział 20. "Wszystko o debugowaniu" (859)
• Rozdziały 21., 22. i 23. Biblioteka STL (859)
• Rozdział 24. "Rzecz o obiektach rozproszonych" (860)
• Rozdział 25. "Korzystanie z technik i bibliotek" (861)
• Rozdział 26. "Wykorzystanie wzorców projektowych" (861)

• C++ (863)
• C++ dla początkujących (863)
• Różne informacje o C++ (864)
• Strumienie wejścia-wyjścia (865)
• Standardowa biblioteka C++ (866)
• Szablony C++ (866)
• Język C (866)
• Integracja C++ z innymi językami (867)
• Algorytmy i struktury danych (867)
• Oprogramowanie open-source (868)
• Metodologie inżynierii programowania (868)
• Styl programowania (869)
• Architektura komputerów (869)
• Wydajność (870)
• Testowanie (870)
• Debugowanie (870)
• Obiekty rozproszone (870)
• CORBA (871)
• XML oraz SOAP (871)
• Wzorce projektowe (872)