jezyk-c++.-koncepcje-i-techniki-programowania full version.pdf

(3066 KB) Pobierz
6
Język C++. Koncepcje i techniki programowania
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
Spis treści
7
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
8
Język C++. Koncepcje i techniki programowania
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
Spis treści
9
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
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ł 27. Klasy, które się śledzą ................................................................... 315
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

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika:

Zgłoś jeśli naruszono regulamin