|
"Język C++. Koncepcje i techniki programowania"
autor: Andrew Koenig, Barbara E. Moo
wydawnictwo: Helion
rok wydania: 2005
ISBN: 83-7361-702-7
liczba stron: 385; oprawa: miękka; format: B5
stan książki: bardzo dobry, minimalne ślady użytkowania
OPIS:
Język C++ to najpopularniejszy obecnie język programowania. Jego podstawowe zalety -- przejrzysta składnia, niewielka ilość słów kluczowych i szeroki wachlarz możliwości -- przysporzyły mu wielu zwolenników. Na rynku dostępnych jest wiele książek o programowaniu w C++, jednak większość z nich zawiera sposoby rozwiązywania konkretnych problemów i zadań programistycznych. Niewiele książek koncentruje się na założeniach, na których opiera się programowanie w języku C++.
W książce "Język C++. Koncepcje i techniki programowania" autorzy skoncentrowali się na kluczowych technikach programowania w C++. Jednak nie przedstawiają ich w formie odpowiedzi na pytania "jak to zrobić", ale "dlaczego robimy to tak, a nie inaczej". Opisują szeroki wachlarz idei i technik programowania w C++ począwszy od szczegółowych przykładów kodu, a skończywszy na zasadach i filozofii projektowania.
* Tworzenie klas
* Uchwyty klas
* Zasady projektowania obiektowego
* Szablony i iteratory
* Stosowanie bibliotek
* Projektowanie bibliotek
* Techniki programowania
Dzięki tej książce nauczysz się nie tylko przestrzegać reguł języka C++, ale także myśleć w tym języku podczas pracy nad programem.
SPIS TREŚCI:
Wstęp (11)
Wprowadzenie (15)
0.1. Podejście pierwsze (15)
0.2. Jak to zrobić bez klas? (18)
0.3. Dlaczego w C++ było łatwiej? (19)
0.4. Bardziej rozbudowany przykład (20)
0.5. Wnioski (20)
Część I Motywacja (23)
Rozdział 1. Dlaczego używam C++? (25)
1.1. Problem (25)
1.2. Historia i kontekst (26)
1.3. Automatyczna dystrybucja oprogramowania (27)
1.4. Czas na C++ (30)
1.5. Oprogramowanie z odzysku (34)
1.6. Postscriptum (35)
Rozdział 2. Dlaczego pracuję nad rozwojem C++? (37)
2.1. Sukces małych projektów (37)
2.2. Abstrakcja (39)
2.3. Maszyny powinny pracować dla ludzi (42)
Rozdział 3. Życie w prawdziwym świecie (43)
Część II Klasy i dziedziczenie (49)
Rozdział 4. Lista kontrolna dla autorów klas (51)
Rozdział 5. Klasy surogatów (61)
5.1. Problem (61)
5.2. Rozwiązanie klasyczne (62)
5.3. Wirtualne funkcje kopiujące (63)
5.4. Definiowanie klasy surogatu (64)
5.5. Podsumowanie (67)
Rozdział 6. Uchwyty - część 1. (69)
6.1. Problem (69)
6.2. Prosta klasa (70)
6.3. Przyłączanie uchwytu (72)
6.4. Dostęp do obiektu (72)
6.5. Prosta implementacja (73)
6.6. Uchwyty z licznikami użycia (74)
6.7. Kopiowanie przy zapisie (76)
6.8. Omówienie (77)
Rozdział 7. Uchwyty - część 2. (79)
7.1. Przypomnienie (80)
7.2. Separowanie licznika użycia (81)
7.3. Abstrahowanie liczników użycia (82)
7.4. Funkcje dostępowe i kopiowanie przy zapisie (84)
7.5. Omówienie (85)
Rozdział 8. Program obiektowy (87)
8.1. Problem (87)
8.2. Rozwiązanie obiektowe (88)
8.3. Klasy uchwytów (91)
8.4. Rozwinięcie 1. - nowe operacje (94)
8.5. Rozwinięcie 2. - nowe typy węzłów (96)
8.6. Refleksje (98)
Rozdział 9. Analiza ćwiczenia praktycznego - część 1. (99)
9.1. Problem (99)
9.2. Projektowanie interfejsu (101)
9.3. Kilka brakujących elementów (103)
9.4. Testowanie interfejsu (104)
9.5. Strategia (104)
9.6. Taktyka (105)
9.7. Łączenie obrazów (108)
9.8. Wnioski (111)
Rozdział 10. Analiza ćwiczenia praktycznego - część 2. (113)
10.1. Strategia (113)
10.2. Korzystanie z możliwości struktury (125)
10.3. Wnioski (128)
Rozdział 11. Kiedy nie używać funkcji wirtualnych? (131)
11.1. Argumenty "za" (131)
11.2. Argumenty "przeciw" (132)
11.3. Szczególna rola destruktorów (137)
11.4. Podsumowanie (139)
Część III Szablony (141)
Rozdział 12. Tworzenie klasy zasobnika (143)
12.1. Co jest w środku? (143)
12.2. Co oznacza kopiowanie zasobnika? (144)
12.3. Jak dostać się do elementów w zasobniku? (147)
12.4. Jak odróżnić odczyt od zapisu? (148)
12.5. Jak poradzić sobie z rozrostem zasobnika? (150)
12.6. Jakie operacje udostępnia zasobnik? (151)
12.7. Jakie są założenia związane z typem elementu zasobnika? (152)
12.8. Zasobniki i dziedziczenie (153)
12.9. Projektowanie klasy "tablicopodobnej" (154)
Rozdział 13. Dostęp do elementów zasobnika (161)
13.1. Imitowanie wskaźnika (161)
13.2. Dostęp do danych (163)
13.3. Pozostałe problemy (165)
13.4. Pointer wskazujący const Array (169)
13.5. Użyteczne dodatki (170)
Rozdział 14. Iteratory (175)
14.1. Uzupełnianie klasy Pointer (175)
14.2. Co to jest iterator? (178)
14.3. Usuwanie elementu (179)
14.4. Usuwanie zasobnika (180)
14.5. Inne względy projektowe (181)
14.6. Podsumowanie (182)
Rozdział 15. Sekwencje (183)
15.1. Dzieło sztuki (183)
15.2. Stara, radykalna idea (185)
15.3. Może jeszcze kilka dodatków... (189)
15.4. Przykład zastosowania (192)
15.5. Może jeszcze coś... (196)
15.6. Do przemyślenia (198)
Rozdział 16. Szablony jako interfejsy (199)
16.1. Problem (199)
16.2. Pierwszy przykład (200)
16.3. Separowanie iteracji (200)
16.4. Iterowanie poprzez dowolne typy (203)
16.5. Dodawanie innych typów (204)
16.6. Uogólnianie sposobu przechowywania (204)
16.7. Dowód przydatności (207)
16.8. Podsumowanie (208)
Rozdział 17. Szablony a algorytmy ogólne (211)
17.1. Konkretny przykład (212)
17.2. Uogólnianie typu elementu (213)
17.3. Przełożenie zliczania elementów na później (214)
17.4. Niezależność od adresu (215)
17.5. Wyszukiwanie w strukturach niebędących tablicami (217)
17.6. Podsumowanie (218)
Rozdział 18. Iteratory ogólne (221)
18.1. Inny algorytm (221)
18.2. Kategorie i wymogi (223)
18.3. Iteratory wejściowe (224)
18.4. Iteratory wyjściowe (224)
18.5. Iteratory postępowe (225)
18.6. Iteratory dwukierunkowe (226)
18.7. Iteratory o dostępie swobodnym (226)
18.8. Dziedziczenie? (227)
18.9. Wydajność (228)
18.10. Podsumowanie (228)
Rozdział 19. Korzystanie z iteratorów ogólnych (231)
19.1. Typy iteratorów (232)
19.2. Wirtualne sekwencje (232)
19.3. Iterator strumienia wyjściowego (234)
19.4. Iterator strumienia wejściowego (236)
19.5. Omówienie (239)
Rozdział 20. Adaptery dla iteratorów (241)
20.1. Przykład (241)
20.2. Asymetria kierunkowa (243)
20.3. Konsekwencja a asymetria (244)
20.4. Automatyczne odwracanie (245)
20.5. Omówienie (247)
Rozdział 21. Obiekty funkcji (249)
21.1. Przykład (249)
21.2. Wskaźniki funkcji (252)
21.3. Obiekty funkcji (254)
21.4. Szablony obiektów funkcji (255)
21.5. Ukrywanie typów pośrednich (256)
21.6. Jeden typ zawiera kilka (257)
21.7. Implementacja (258)
21.8. Omówienie (260)
Rozdział 22. Adaptery funkcji (261)
22.1. Dlaczego obiekty funkcji? (261)
22.2. Obiekty funkcji dla operatorów wbudowanych (262)
22.3. Funkcje wiążące (263)
22.4. Spojrzenie z bliska (264)
22.5. Dziedziczenie interfejsu (265)
22.6. Używanie klas (266)
22.7. Omówienie (267)
Część IV Biblioteki (269)
Rozdział 23. Biblioteki w bieżącym zastosowaniu (271)
23.1. Problem (271)
23.2. Istota problemu - część 1. (273)
23.3. Implementacja - część 1. (273)
23.4. Istota problemu - część 2. (276)
23.5. Implementacja - część 2. (276)
23.6. Omówienie (278)
Rozdział 24. Obiektowa lekcja projektowania interfejsu biblioteki (281)
24.1. Komplikacje (282)
24.2. Poprawianie interfejsu (283)
24.3. Szczegółowe rozważania (285)
24.4. Pisanie kodu (286)
24.5. Wnioski (288)
Rozdział 25. Projektowanie bibliotek jako budowanie języka (289)
25.1. Ciągi znakowe (289)
25.2. Wyczerpanie dostępnej pamięci (290)
25.3. Kopiowanie (293)
25.4. Ukrywanie implementacji (296)
25.5. Konstruktor domyślny (298)
25.6. Inne operacje (299)
25.7. Podciągi (301)
25.8. Wnioski (302)
Rozdział 26. Projektowanie języka jako budowanie bibliotek (303)
26.1. Abstrakcyjne typy danych (303)
26.2. Biblioteki i abstrakcyjne typy danych (305)
26.3. Rezerwacja pamięci (308)
26.4. Przyporządkowywanie i inicjalizacja składowych klas (309)
26.5. Obsługa wyjątków (311)
26.6. Podsumowanie (312)
Część V Techniki (313)
Rozdział 27. Klasy, które się śledzą (315)
27.1. Projektowanie klasy śledzącej (315)
27.2. Tworzenie martwego kodu (318)
27.3. Generowanie wyników inspekcji dla obiektów (319)
27.4. Weryfikowanie zachowania zasobnika (321)
27.5. Podsumowanie (325)
Rozdział 28. Grupowy przydział pamięci dla obiektów (327)
28.1. Problem (327)
28.2. Projektowanie rozwiązania (327)
28.3. Implementacja (330)
28.4. Dziedziczenie (332)
28.5. Podsumowanie (333)
Rozdział 29. Aplikatory, manipulatory i obiekty funkcji (335)
29.1. Problem (336)
29.2. Rozwiązanie (338)
29.3. Inne rozwiązanie (338)
29.4. Dodatkowe argumenty (340)
29.5. Przykład (341)
29.6. Formy skrócone (343)
29.7. Przemyślenia (344)
29.8. Uwagi historyczne, źródła i podziękowania (345)
Rozdział 30. Uniezależnianie bibliotek aplikacji od wejść i wyjść (347)
30.1. Problem (347)
30.2. Rozwiązanie 1. - spryt i metoda siłowa (348)
30.3. Rozwiązanie 2. - abstrakcyjne wyjście (349)
30.4. Rozwiązanie 3. - spryt bez metody siłowej (351)
30.5. Uwagi (354)
Część VI Podsumowanie (355)
Rozdział 31. Przez złożoność do prostoty (357)
31.1. Świat jest złożony (357)
31.2. Złożoność staje się ukryta (358)
31.3. Komputery mają to samo (359)
31.4. Komputery rozwiązują prawdziwe problemy (361)
31.5. Biblioteki klas i semantyka języka (362)
31.6. Ułatwianie jest trudne (364)
31.7. Abstrakcja a interfejs (365)
31.8. Konserwacja złożoności (366)
Rozdział 32. "Witaj świecie" i co dalej? (367)
32.1. Znajdź w pobliżu eksperta (367)
32.2. Wybierz narzędzie i opanuj je (368)
32.3. Niektóre elementy C są ważne... (368)
32.4. ...inne niekoniecznie (370)
32.5. Wyznacz sobie szereg problemów do rozwiązania (371)
32.6. Konkluzja (374)
Dodatki (377)
Skorowidz (379)
|
