.:$$:.

Zakładając znajomość podstaw języka C++ książka ta umożliwia programistom rozwinięcie zaawansowanych umiejętności programowania poprzez stosowanie styli i idiomów języka C++. Struktura książki zorganizowana jest wokół abstrakcji wspieranych przez język C++: abstrakcyjnych typów danych, kombinacji typów w strukturach dziedziczenia, programowania obiektowego i dziedziczenia wielokrotnego. W książce przedstawione zostają także te idiomy, które nie znajdują bezpośredniego wsparcia w języku C++, takie jak wirtualne konstruktory, obiekty prototypów i zaawansowane techniki odzyskiwania nieużytków.

• Przedstawia zalety i potencjalne pułapki zaawansowanych technik programowania w języku C++.
• Sposoby efektywnego łączenia abstrakcji języka C++ ilustruje szeregiem krótkich, ale stanowiących wystarczający instruktaż przykładów.
• Dostarcza wielu praktycznych zasad wykorzystania języka C++ do implementacji rezultatów projektowania obiektowego.
• Omawia wszystkie właściwości edycji 3.0 języka C++, w tym zastosowanie szablonów w celu wielokrotnego wykorzystania kodu.
• Przedstawia istotne aspekty rozwoju złożonych systemów, w tym projektowanie bibliotek, obsługę wyjątków i przetwarzanie rozproszone.

Książka ta jest ważnym podręcznikiem dla każdego programisty aplikacji lub programisty systemowego posługującego się językiem C++.

O autorze:
James Coplien pracuje w departamencie związanym z badaniami nad produkcją oprogramowania w firmie AT&T Bell Laboratories. Jest także konsultantem przy dużych projektach wykorzystujących technologie obiektowe. [więcej...\

• 1.1. Ewolucja języka C++ (15)
• 1.2. Idiomy jako sposób na złożoność problemów (16)
• 1.3. Obiekty lat 90-tych (18)
• 1.4. Projektowanie i język programowania (19)
• Bibliografia (20)

• 2.1. Klasy (22)
• 2.2. Inwersja obiektowa (25)
• 2.3. Konstruktory i destruktory (28)
• 2.4. Funkcje rozwijane w miejscu wywołania (32)
• 2.5. Inicjacja statycznych danych składowych (34)
• 2.6. Statyczne funkcje składowe (35)
• 2.7. Zakresy i słowo kluczowe const (36)
• 2.8. Porządek inicjacji obiektów globalnych, stałych i składowych statycznych (38)
• 2.9. Słowo const i funkcje składowe (39)
• 2.10. Wskaźniki funkcji składowych (41)
• 2.11. Konwencje programowania (45)
• Ćwiczenia (46)
• Bibliografia (47)

• 3.1. Ortodoksyjna postać kanoniczna klasy (50)
• 3.2. Zakresy i kontrola dostępu (56)
• 3.3. Przeciążanie - zmiana semantyki funkcji i operatorów (59)
• 3.4. Konwersja typu (64)
• 3.5. Zliczanie referencji i zmienne wykorzystujące "magiczną" pamięć (67)
• 3.6. Operatory new i delete (80)
• 3.7. Separacja tworzenia instancji i jej inicjacji (85)
• Ćwiczenia (88)
• Bibliografia (90)

• 4.1. Dziedziczenie pojedyncze (93)
• 4.2. Zakresy deklaracji i kontrola dostępu (99)
• 4.3. Konstruktory i destruktory (109)
• 4.4. Konwersje wskaźników klas (112)
• 4.5. Selektory typu (114)
• Ćwiczenia (116)
• Bibliografia (118)

• 5.1. Funkcje wirtualne (121)
• 5.2. Interakcje destruktorów i destruktory wirtualne (128)
• 5.3. Funkcje wirtualne i zakresy (129)
• 5.4. Funkcje czysto wirtualne i abstrakcyjne klasy bazowe (131)
• 5.5. Klasa kopertowa i klasa listu (133)
• 5.6. Funktory - funkcje jako obiekty (161)
• 5.7. Dziedziczenie wielokrotne (172)
• 5.8. Kanoniczna postać dziedziczenia (182)
• Ćwiczenia (186)
• Przykład iteratora kolejki (187)
• Przykład klas prostej aplikacji bankowej (188)
• Bibliografia (190)

• 6.1. Typy i klasy (192)
• 6.2. Czynności projektowania obiektowego (196)
• 6.3. Analiza obiektowa i analiza dziedziny (199)
• 6.4. Związki obiektów i klas (202)
• 6.5. Podtypy, dziedziczenie i przekazywanie (210)
• 6.6. Praktyczne zasady tworzenia podtypów, stosowania dziedziczenia i niezależności klas (229)
• Ćwiczenia (231)
• Bibliografia (232)

• 7.1. Gdy analogie przestają działać (235)
• 7.2. Projektowanie z myślą o ponownym użyciu (237)
• 7.3. Cztery mechanizmy ponownego użycia kodu (239)
• 7.4. Typy parametryczne czyli szablony (241)
• 7.5. Ponowne użycie i dziedziczenie prywatne (249)
• 7.6. Ponowne użycie pamięci (252)
• 7.7. Ponowne użycie interfejsu - warianty (253)
• 7.8. Ponowne użycie, dziedziczenie i przekazywanie (255)
• 7.9. Ponowne użycie kodu źródłowego (256)
• 7.10. Ogólne uwagi na temat ponownego użycia (259)
• Ćwiczenia (260)
• Bibliografia (261)

• 8.1. Przykład - przykłady pracowników (266)
• 8.2. Konstruktory ogólne - idiom zespołu przykładów (271)
• 8.3. Autonomiczne konstruktory ogólne (273)
• 8.4. Abstrakcyjne przykłady bazowe (275)
• 8.5. Ku idiomowi szkieletu przykładu (278)
• 8.6. Uwagi na temat notacji (280)
• 8.7. Przykłady i administracja kodem programu (282)
• Ćwiczenia (283)
• Prosty parser wykorzystujący przykłady (284)
• Przykład wykorzystujący szczeliny (286)
• Bibliografia (288)

• 9.1. Przyrostowy rozwój programów w języku C++ (291)
• 9.2. Symboliczna postać kanoniczna (293)
• 9.3. Przykład - ogólna klasa kolekcji (304)
• 9.4. Kod i idiomy obsługujące mechanizm ładowania przyrostowego (308)
• 9.5. Odzyskiwanie nieużytków (318)
• 9.6. Hermetyzacja typów podstawowych (327)
• 9.7. Wielometody i idiom symboliczny (328)
• Ćwiczenia (332)
• Bibliografia (333)

• 10.1. Przykład - system okienkowy (336)
• 10.2. Ograniczenia (339)

• 11.1. Statyczne projektowanie systemów (342)
• 11.2. Dynamiczne projektowanie systemów (350)
• Bibliografia (365)

• A.1. Wywołania funkcji (367)
• A.2. Parametry funkcji (368)
• A.3. Prototypy funkcji (369)
• A.4. Przekazywanie parametrów przez referencję (370)
• A.5. Zmienna liczba parametrów (371)
• A.6. Wskaźniki funkcji (373)
• A.7. Słowo kluczowe const jako modyfikator typu (375)
• A.8. Interfejs z programami w języku C (377)
• Ćwiczenia (389)
• Bibliografia (390)

• D.1. Dlaczego kopiowanie składowych nie rozwiązuje problemu? (408)

• F.1. Programowanie strukturalne - wprowadzenie (447)
• F.2. Elementy programowania strukturalnego w języku C++ (448)
• F.3. Alternatywa dla bloków z głęboko zagnieżdżonymi zakresami (451)
• F.4. Rozważania na temat implementacji (455)
• Ćwiczenia (456)
• Gra wykorzystująca idiom strukturalny (457)
• Bibliografia (460)