www.pridecafe.net
okladka

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.

Książka przedstawia między innymi:
  • 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...\


Przedmowa (9)
Wprowadzenie (11)
Rozdział 1. Abstrakcja (15)
  • 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)
Rozdział 2. Klasy (27)
  • 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)
Rozdział 3. Uchwyty (59)
  • 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)
Rozdział 4. Dziedziczenie (75)
  • 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)
Rozdział 5. Dziedziczenie wielokrotne (91)
  • 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)
Rozdział 6. Projektowanie pod kątem dziedziczenia (103)
  • 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)
Rozdział 7. Szablony (119)
  • 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)
Rozdział 8. Szablony zaawansowane (139)
  • 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)
Rozdział 9. Możliwość ponownego wykorzystania (171)
  • 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)
Rozdział 10. Wyjątki (209)
  • 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)
Rozdział 11. Przenoszenie projektów do C++ (221)
  • 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)
Skorowidz (229)