.:$$:.

Poznanie ruchów figur szachowych to dopiero pierwszy krok w nauce tej gry. Aby ją opanować, trzeba zrozumieć strategie i taktyki, które wpływają na każdy ruch. To samo dotyczy języka C++. Znajomość właściwych strategii pomaga unikać pułapek i pracować o wiele skuteczniej. Rob Murray dzieląc się swoim doświadczeniem pomaga programistom C++ wykonać następny krok w kierunku tworzenia wydajnych aplikacji.

Licznie występujące w całej książce przykłady kodu mają na celu zilustrowanie przydatnych strategii programistycznych i ostrzec przed nabyciem niebezpiecznych nawyków. Aby dodatkowo ułatwić przyswajanie nowych umiejętności, każdy rozdział kończy się listą poruszonych w nim kluczowych zagadnień oraz pytaniami mającymi spowodować przemyślenia i dyskusje.

• Tworzenie właściwych abstrakcji dla projektu i przekształcanie abstrakcji w klasy C++
• Mechanizmy dziedziczenia pojedynczego i wielokrotnego
• Metody tworzenia klas
• Szczegółowy opis mechanizmu szablonów
• Wskazówki dotyczące stosowania wyjątków
• Metody tworzenia kodu nadającego się do wielokrotnego wykorzystania
• Przenoszenie programów z języka C do C++

Robert B. Murray jest wicedyrektorem ds. inżynierii oprogramowania w firmie Quantitative Data Systems dostarczającej niestandardowych rozwiązań z zakresu oprogramowania dla czołowych firm. [więcej...\

• 1.1. Abstrakcja numeru telefonu (17)
• 1.2. Związki między abstrakcjami (19)
• 1.3. Problem warunków brzegowych (24)
• 1.4. Projektowanie z wykorzystaniem kart CRC (25)
• 1.5. W skrócie (26)
• 1.6. Pytania (26)

• 2.1. Konstruktory (27)
• 2.2. Przypisanie (34)
• 2.3. Dane publiczne (36)
• 2.4. Niejawne konwersje typów (40)
• 2.5. Operatory przeciążone - składowe czy nie? (44)
• 2.6. Przeciążenie, argumenty domyślne i wielokropek (47)
• 2.7. Słowo kluczowe const (48)
• 2.8. Zwracanie referencji (54)
• 2.9. Konstruktory statyczne (55)
• 2.10. W skrócie (56)
• 2.11. Pytania (57)

• 3.1. Klasa Lancuch (60)
• 3.2. Unikanie kopiowania przez zastosowanie liczników użycia (61)
• 3.3. Zapobieganie powtórnym kompilacjom - "Kot z Cheshire" (66)
• 3.4. Stosowanie uchwytów w celu ukrycia szczegółów projektu (68)
• 3.5. Implementacje wielokrotne (69)
• 3.6. Uchwyty jako obiekty (72)
• 3.7. Podsumowanie (73)
• 3.8. W skrócie (73)
• 3.9. Pytania (73)

• 4.1. Związek generalizacji (specjalizacji) (75)
• 4.2. Dziedziczenie publiczne (78)
• 4.3. Dziedziczenie prywatne (78)
• 4.4. Dziedziczenie chronione (82)
• 4.5. Zgodność z abstrakcjami klasy bazowej (83)
• 4.6. Funkcje czysto wirtualne (85)
• 4.7. Szczegóły i pułapki związane z dziedziczeniem (87)
• 4.8. W skrócie (90)
• 4.9. Pytania (90)

• 5.1. Dziedziczenie wielokrotne jako iloczyn zbiorów (91)
• 5.2. Wirtualne klasy bazowe (96)
• 5.3. Pewne szczegóły dotyczące dziedziczenia wielokrotnego (99)
• 5.4. W skrócie (101)
• 5.5. Pytania (101)

• 6.1. Interfejs chroniony (103)
• 6.2. Czy należy projektować pod kątem dziedziczenia? (106)
• 6.3. Projektowanie pod kątem dziedziczenia - kilka przykładów (111)
• 6.4. Podsumowanie (116)
• 6.5. W skrócie (116)
• 6.6. Pytania (117)

• 7.1. Szablon klasy Para (119)
• 7.2. Kilka szczegółów dotyczących szablonów (122)
• 7.3. Konkretyzacja szablonu (123)
• 7.4. Inteligentne wskaźniki (125)
• 7.5. Argumenty wyrażeniowe szablonów (131)
• 7.6. Szablony funkcji (132)
• 7.7. W skrócie (135)
• 7.8. Pytania (136)

• 8.1. Klasy kontenerowe wykorzystujące szablony (139)
• 8.2. Przykład - klasa Blok (141)
• 8.3. Szczegóły projektowe klasy Blok (143)
• 8.4. Kontenery z iteratorami - klasa Lista (148)
• 8.5. Zagadnienia dotyczące projektowania iteratorów (154)
• 8.6. Zagadnienia dotyczące wydajności (157)
• 8.7. Ograniczenia dotyczące argumentów szablonów (160)
• 8.8. Specjalizacje szablonów (162)
• 8.9. W skrócie (168)
• 8.10. Pytania (168)

• 9.1. Poznanie i nabycie (172)
• 9.2. Odporność (173)
• 9.3. Zarządzanie pamięcią (179)
• 9.4. Alternatywne metody alokacji pamięci (181)
• 9.5. Przekazywanie argumentów do operatora new (184)
• 9.6. Zarządzanie zasobami zewnętrznymi (187)
• 9.7. Znajdowanie błędów pamięci (187)
• 9.8. Konflikty nazw (192)
• 9.9. Wydajność (195)
• 9.10. Nie zgaduj - zmierz! (195)
• 9.11. Algorytmy (196)
• 9.12. Wąskie gardła w dynamicznej alokacji pamięci (197)
• 9.13. Funkcje rozwijane w miejscu wywołania (202)
• 9.14. Prawo Tiemanna (204)
• 9.15. W skrócie (204)
• 9.16. Pytania (205)

• 10.1. Sprostowanie (209)
• 10.2. Dlaczego wyjątki? (209)
• 10.3. Przykład wyjątku (212)
• 10.4. Wyjątki powinny być wyjątkowe (213)
• 10.5. Zrozumieć wyjątki (215)
• 10.6. Oszacowanie winy (215)
• 10.7. Projektowanie obiektu wyjątku (217)
• 10.8. W skrócie (219)
• 10.9. Pytania (219)

• 11.1. Wybór języka C++ (221)
• 11.2. Przyswajanie C++ (223)
• 11.3. Projektowanie i implementacja (224)
• 11.4. Tworzenie bazy zasobów (226)
• 11.5. Uwagi końcowe (227)
• 11.6. W skrócie (227)
• 11.7. Pytania (228)