Jezyk C Koncepcje i techniki programowania.pdf

(334 KB) Pobierz
IDZ DO
PRZYK£ADOWY ROZDZIA£
SPIS TRE CI
KATALOG KSI¥¯EK
KATALOG ONLINE
ZAMÓW DRUKOWANY KATALOG
Jêzyk C++. Koncepcje
i techniki programowania
Autor: Andrew Koenig, Barbara Moo
T³umaczenie: Jaros³aw Dobrzañski
ISBN: 83-7361-702-7
Tytu³ orygina³u:
Ruminations on C++
Format: B5, stron: 362
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¿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.
CENNIK I INFORMACJE
ZAMÓW INFORMACJE
O NOWO CIACH
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 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
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ł 1. Dlaczego używam C++? ................................................................... 25
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
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

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika:

Zgłoś jeśli naruszono regulamin