Jezyk C++ Koncepcje i techniki programowania, Programowanie
[ Pobierz całość w formacie PDF ]
IDZ DO
PRZYK£ADOW
Jêzyk C++. Koncepcje
i techniki programowania
SPIS TRECI
KATALOG KSI¥¯EK
Autor: Andrew Koenig, Barbara Moo
T³umaczenie: Jaros³aw Dobrzañski
ISBN: 83-7361-702-7
Tytu³ orygina³
Format: B5, stron: 362
KATALOG ONLINE
ZAMÓW DRUKOWANY KATALOG
TWÓJ KOSZYK
DODAJ DO KOSZYKA
Jêzyk C++ to najpopularniejszy obecnie jêzyk programowania. Jego podstawowe zalety
— przejrzysta sk³adnia, niewielka iloæ s³ów kluczowych i szeroki wachlarz mo¿liwoci —
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
myleæ w tym jêzyku podczas pracy nad programem.
CENNIK I INFORMACJE
ZAMÓW INFORMACJE
O NOWOCIACH
ZAMÓW CENNIK
CZYTELNIA
FRAGMENTY KSI¥¯EK ONLINE
Wydawnictwo Helion
ul. Chopina 6
44-100 Gliwice
tel. (32)230-98-63
e-mail: helion@helion.pl
Spis treci
Wstp .............................................................................................11
Wprowadzenie .................................................................................15
0.1. Podejcie 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 uywam 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. Rozwi5zanie klasyczne...........................................................................................62
5.3. Wirtualne funkcje kopiuj5ce...................................................................................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ł5czanie uchwytu.............................................................................................72
6
Jzyk C++. Koncepcje i techniki programowania
6.4. Dost7p do obiektu...................................................................................................72
6.5. Prosta implementacja..............................................................................................73
6.6. Uchwyty z licznikami u9ycia..................................................................................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 u9ycia...................................................................................81
7.3. Abstrahowanie liczników u9ycia............................................................................82
7.4. Funkcje dost7powe i kopiowanie przy zapisie........................................................84
7.5. Omówienie.............................................................................................................85
Rozdział 8. Program obiektowy..........................................................................87
8.1. Problem ..................................................................................................................87
8.2. Rozwi5zanie obiektowe..........................................................................................88
8.3. Klasy uchwytów.....................................................................................................91
8.4. Rozwini7cie 1. — nowe operacje...........................................................................94
8.5. Rozwini7cie 2. — nowe typy w7złó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 brakuj5cych elementów ..............................................................................103
9.4. Testowanie interfejsu............................................................................................104
9.5. Strategia................................................................................................................104
9.6. Taktyka.................................................................................................................105
9.7. Ł5czenie obrazów.................................................................................................108
9.8. Wnioski................................................................................................................111
Rozdział 10.Analiza /wiczenia praktycznego — cz%/ 2. ...................................113
10.1. Strategia................................................................................................................ 113
10.2. Korzystanie z mo9liwoci struktury .....................................................................125
10.3. Wnioski................................................................................................................128
Rozdział 11.Kiedy nie uywa/ 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 si7 do elementów w zasobniku?..........................................................147
12.4. Jak odró9ni odczyt od zapisu?............................................................................148
12.5. Jak poradzi sobie z rozrostem zasobnika?...........................................................150
12.6. Jakie operacje udost7pnia zasobnik?....................................................................151
12.7. Jakie s5 zało9enia zwi5zane z typem elementu zasobnika?..................................152
12.8. Zasobniki i dziedziczenie.....................................................................................153
12.9. Projektowanie klasy „tablicopodobnej”................................................................154
Spis treci
7
Rozdział 13.Dostp do elementów zasobnika ....................................................161
13.1. Imitowanie wskaCnika..........................................................................................161
13.2. Dost7p do danych.................................................................................................163
13.3. Pozostałe problemy ..............................................................................................165
13.4. Pointer wskazuj5cy const Array ...........................................................................169
13.5. U9yteczne 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 wzgl7dy projektowe......................................................................................181
14.6. Podsumowanie......................................................................................................182
Rozdział 15.Sekwencje.....................................................................................183
15.1. Dzieło sztuki.........................................................................................................183
15.2. Stara, radykalna idea ............................................................................................185
15.3. Mo9e jeszcze kilka dodatków…...........................................................................189
15.4. Przykład zastosowania..........................................................................................192
15.5. Mo9e jeszcze co…..............................................................................................196
15.6. Do przemylenia...................................................................................................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 przydatnoci.............................................................................................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ło9enie zliczania elementów na póCniej.........................................................214
17.4. Niezale9no od adresu........................................................................................215
17.5. Wyszukiwanie w strukturach nieb7d5cych 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 wejciowe ..............................................................................................224
18.4. Iteratory wyjciowe..............................................................................................224
18.5. Iteratory post7powe..............................................................................................225
18.6. Iteratory dwukierunkowe......................................................................................226
18.7. Iteratory o dost7pie 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
8
Jzyk C++. Koncepcje i techniki programowania
19.3. Iterator strumienia wyjciowego...........................................................................234
19.4. Iterator strumienia wejciowego...........................................................................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. WskaCniki funkcji.................................................................................................252
21.3. Obiekty funkcji.....................................................................................................254
21.4. Szablony obiektów funkcji...................................................................................255
21.5. Ukrywanie typów porednich...............................................................................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 wi595ce...................................................................................................263
22.4. Spojrzenie z bliska................................................................................................264
22.5. Dziedziczenie interfejsu .......................................................................................265
22.6. U9ywanie 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 — cz7 1. .................................................................................273
23.3. Implementacja — cz7 1. ...................................................................................273
23.4. Istota problemu — cz7 2. .................................................................................276
23.5. Implementacja — cz7 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 rozwa9ania......................................................................................285
24.4. Pisanie kodu.........................................................................................................286
24.5. Wnioski................................................................................................................288
Rozdział 25.Projektowanie bibliotek jako budowanie jzyka...............................289
25.1. Ci5gi znakowe......................................................................................................289
25.2. Wyczerpanie dost7pnej pami7ci...........................................................................290
25.3. Kopiowanie..........................................................................................................293
25.4. Ukrywanie implementacji.....................................................................................296
25.5. Konstruktor domylny..........................................................................................298
25.6. Inne operacje........................................................................................................299
25.7. Podci5gi................................................................................................................301
25.8. Wnioski................................................................................................................302
[ Pobierz całość w formacie PDF ]