• Jak korzystać z wzorców projektowych w C++?
• Jak stworzyć dokładnie jedną instancję obiektu?
• Jak używać inteligentnych wskaźników?

Język C++ jest obecny na rynku już niemal trzydzieści lat, a jednak nadal świetnie spełnia swoje zadania. Jest powszechnie używany, a wręcz niezastąpiony w wielu dziedzinach programowania. Wszędzie tam, gdzie potrzebna jest najwyższa wydajność oraz pełna kontrola nad zasobami i przebiegiem programu, sprawdza się wyśmienicie. Wystarczy odrobina chęci, dobry podręcznik i trochę czasu, aby wykorzystać pełną moc C++ w nowoczesnych technikach programowania.

Książkę, która Ci w tym pomoże, trzymasz właśnie w rękach. Czy znajdziesz czas i ochotę, aby zgłębić zawartą w niej wiedzę? Gwarantujemy, że warto! W trakcie lektury dowiesz się, jak zaimplementować w C++ najpopularniejsze wzorce projektowe. Dzięki nim błyskawicznie oprogramujesz typowe rozwiązania. Nauczysz się tworzyć dokładnie jedną instancję obiektu oraz zobaczysz, jak korzystać z fabryki obiektów czy inteligentnych wskaźników. Ponadto zapoznasz się z technikami projektowania klas, asercjami w trakcie kompilacji oraz uogólnionymi funktorami. Dzięki tej książce poczujesz na nowo satysfakcję z pisania programów w języku C++!

• Projektowanie klas
• Asercje czasu kompilacji
• Listy typów
• Alokowanie małych obiektów
• Funktory uogólnione
• Inteligentne wskaźniki
• Fabryka obiektów i fabryka abstrakcyjna
• Tworzenie dokładnie jednego obiektu - wzorzec singleton
• Multimetody

Czerp satysfakcję z korzystania z nowoczesnych technik programowania w C++.

Spis treści:

I: Techniki (21)
1. Klasy konfigurowane wytycznymi (23)

• 1.1. Projektowanie oprogramowania - klęska urodzaju? (23)
• 1.2. Porażka interfejsu "wszechstronnego" (24)
• 1.3. Ratunek w wielodziedziczeniu? (26)
• 1.4. Zalety szablonów (26)
• 1.5. Wytyczne i klasy wytycznych (28)
• 1.6. Wytyczne rozszerzone (32)
• 1.7. Destruktory klas wytycznych (33)
• 1.8. Elementy opcjonalne w konkretyzacji częściowej (34)
• 1.9. Łączenie klas wytycznych (35)
• 1.10. Klasy wytycznych a konfigurowanie struktury (37)
• 1.11. Wytyczne zgodne i niezgodne (38)
• 1.12. Dekompozycja klas na wytyczne (40)
• 1.13. Podsumowanie (42)

2. Techniki (43)

• 2.1. Asercje statyczne (44)
• 2.2. Częściowa specjalizacja szablonu (46)
• 2.3. Klasy lokalne (48)
• 2.4. Mapowanie stałych na typy (49)
• 2.5. Odwzorowanie typu na typ (52)
• 2.6. Wybór typu (53)
• 2.7. Statyczne wykrywanie dziedziczenia i możliwości konwersji (55)
• 2.8. TypeInfo (58)
• 2.9. NullType i EmptyType (60)
• 2.10. Cechy typów (61)
• 2.11. Podsumowanie (68)

3. Listy typów (71)

• 3.1. Listy typów - do czego? (71)
• 3.2. Definiowanie list typów (73)
• 3.3. Liniowe tworzenie list typów (75)
• 3.4. Obliczanie długości listy (76)
• 3.5. Przygrywka (77)
• 3.6. Dostęp swobodny (indeksowany) (77)
• 3.7. Przeszukiwanie list typów (79)
• 3.8. Dopisywanie do listy typów (80)
• 3.9. Usuwanie typu z listy (81)
• 3.10. Usuwanie duplikatów (82)
• 3.11. Zastępowanie elementu na liście typów (83)
• 3.12. Częściowe porządkowanie listy typów (84)
• 3.13. Generowanie klas z list typów (87)
• 3.14. Podsumowanie (97)
• 3.15. Listy typów - na skróty (97)

4. Przydział pamięci dla niewielkich obiektów (101)

• 4.1. Domyślny alokator pamięci dynamicznej (102)
• 4.2. Zasada działania alokatora pamięci (102)
• 4.3. Alokator małych obiektów (104)
• 4.4. Chunk (105)
• 4.5. Alokator przydziałów o stałym rozmiarze (108)
• 4.6. Klasa SmallObjAlocator (112)
• 4.7. 3 x Tak (113)
• 4.8. Proste, skomplikowane, a potem znów proste (116)
• 4.9. Konfigurowanie alokatora (117)
• 4.10. Podsumowanie (118)
• 4.11. Alokator małych obiektów - na skróty (119)

II: Komponenty (121)
5. Uogólnione obiekty funkcyjne (123)

• 5.1. Wzorzec Command (124)
• 5.2. Wzorzec Command w praktyce (126)
• 5.3. Byty funkcyjne w C++ (127)
• 5.4. Szkielet szablonu klasy Functor (129)
• 5.5. Delegowanie wywołania Functor::operator() (133)
• 5.6. Funktory (135)
• 5.7. Raz a dobrze (137)
• 5.8. Konwersje typów argumentów i wartości zwracanej (139)
• 5.9. Wskaźniki do metod (140)
• 5.10. Wiązanie argumentów wywołania (144)
• 5.11. Żądania skomasowane (147)
• 5.12. Z życia wzięte (1) - duży koszt delegacji funkcji (147)
• 5.13. Z życia wzięte (2) - alokacje na stercie (149)
• 5.14. Szablon Functor w implementacji cofnij-powtórz (150)
• 5.15. Podsumowanie (151)
• 5.16. Functor - na skróty (152)

6. Singletony (155)

• 6.1. Statyczne dane i statyczne funkcje nie czynią singletona (156)
• 6.2. Podstawowe idiomy C++ dla singletonów (157)
• 6.3. Wymuszanie unikalności (158)
• 6.4. Usuwanie singletona (159)
• 6.5. Problem martwych referencji (162)
• 6.6. Problem martwych referencji (1) - singleton a la feniks (164)
• 6.7. Problem martwych referencji (2) - sterowanie żywotnością (167)
• 6.8. Implementowanie singletonów z żywotnością (169)
• 6.9. Życie w wielu wątkach (173)
• 6.10. Podsumowanie doświadczeń (176)
• 6.11. Stosowanie szablonu SingletonHolder (181)
• 6.12. Podsumowanie (183)
• 6.13. Szablon klasy SingletonHolder - na skróty (183)

7. Inteligentne wskaźniki (185)

• 7.1. Elementarz inteligentnych wskaźników (186)
• 7.2. Oferta (187)
• 7.3. Przydział obiektów inteligentnych wskaźników (188)
• 7.4. Metody inteligentnego wskaźnika (190)
• 7.5. Strategie zarządzania posiadaniem (191)
• 7.6. Operator pobrania adresu (199)
• 7.7. Niejawna konwersja na typ gołego wskaźnika (200)
• 7.8. Równość i różność (202)
• 7.9. Porównania porządkujące (207)
• 7.10. Kontrola i raportowanie o błędach (210)
• 7.11. Wskaźniki niemodyfikowalne i wskaźniki do wartości niemodyfikowalnych (211)
• 7.12. Tablice (212)
• 7.13. Inteligentne wskaźniki a wielowątkowość (213)
• 7.14. Podsumowanie doświadczeń (217)
• 7.15. Podsumowanie (223)
• 7.16. Wskaźniki SmartPtr - na skróty (224)

8. Wytwórnie obiektów (225)

• 8.1. Przydatność wytwórni obiektów (226)
• 8.2. Wytwórnie obiektów w C++ - klasy a obiekty (228)
• 8.3. Implementowanie wytwórni obiektów (229)
• 8.4. Identyfikatory typu (234)
• 8.5. Uogólnienie (235)
• 8.6. Sprostowania (239)
• 8.7. Wytwórnie klonów (240)
• 8.8. Stosowanie wytwórni obiektów z innymi komponentami uogólnionymi (243)
• 8.9. Podsumowanie (244)
• 8.10. Szablon klasy Factory - na skróty (244)
• 8.11. Szablon klasy CloneFactory - na skróty (245)

9. Wzorzec Abstract Factory (247)

• 9.1. Rola wytwórni abstrakcyjnej w architekturze (247)
• 9.2. Interfejs uogólnionej wytwórni abstrakcyjnej (251)
• 9.3. Implementacja AbstractFactory (254)
• 9.4. Implementacja wytwórni abstrakcyjnej z prototypowaniem (256)
• 9.5. Podsumowanie (261)
• 9.6. Szablony AbstractFactory i ConcreteFactory - na skróty (262)

10. Wzorzec Visitor (265)

• 10.1. Elementarz modelu wizytacji (265)
• 10.2. Przeciążenia i metoda wychwytująca (271)
• 10.3. Wizytacja acykliczna (273)
• 10.4. Uogólniona implementacja wzorca Visitor (278)
• 10.5. Powrót do wizytacji "cyklicznej" (284)
• 10.6. Wariacje (287)
• 10.7. Podsumowanie (290)
• 10.8. Uogólnione komponenty wzorca wizytacji - na skróty (290)

11. Wielometody (293)

• 11.1. Czym są wielometody? (294)
• 11.2. Przydatność wielometod (295)
• 11.3. Podwójne przełączanie - metoda siłowa (296)
• 11.4. Metoda siłowa w wersji automatyzowanej (298)
• 11.5. Symetria rozprowadzania metodą siłową (303)
• 11.6. Rozprowadzanie logarytmiczne (307)
• 11.7. Symetria w FnDispatcher (312)
• 11.8. Podwójne rozprowadzanie do funktorów (313)
• 11.9. Konwertowanie argumentów - statyczne czy dynamiczne? (316)
• 11.10. Wielometody o stałym czasie rozprowadzania (321)
• 11.11. BasicDispatcher i BasicFastDispatcher w roli wytycznych (324)
• 11.12. Naprzód (325)
• 11.13. Podsumowanie (327)
• 11.14. Podwójne rozprowadzanie - na skróty (328)

A: Minimalistyczna biblioteka wielowątkowa (333)

• A.1. Krytyka wielowątkowości (334)
• A.2. Podejście a la Loki (335)
• A.3. Operacje niepodzielne na typach całkowitoliczbowych (335)
• A.4. Muteksy (337)
• A.5. Semantyka blokowania w programowaniu obiektowym (339)
• A.6. Opcjonalny modyfikator volatile (341)
• A.7. Semafory, zdarzenia i inne (342)
• A.8. Podsumowanie (342)