język c++. gotowe rozwiązania dla programistów pełna wersja.pdf

(9569 KB) Pobierz
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
IDZ DO
PRZYK£ADOW Y ROZDZIA£
Jêzyk C++. Gotowe
rozwi¹zania dla programistów
SPIS TRECI
KATALOG KSI¥¯EK
Autor: Matthew Wilson
T³umaczenie: Zbigniew Banach,
Micha³ Dadan, Tomasz Walczak
ISBN: 83-7361-841-4
Tytu³ orygina³ u: Imperfect C++:
Format: B5, stron: 696
KATALOG ONLINE
ZAMÓW DRUKOWANY KATALOG
TWÓJ KOSZYK
DODAJ DO KOSZYKA
C++ to popularny i uniwersalny jêzyk programowania. Jednak po d³u¿szym stosowaniu
programici zaczynaj¹ zauwa¿aæ pewne jego niedoskona³oci i ograniczenia. System
typów, sposób dzia³ania niektórych kompilatorów, zwi¹zki pomiêdzy wskanikami
i tablicami, nieprzewidziane w standardzie zachowania obiektów statycznych i bibliotek
dynamicznych to tylko niektóre z nich. Aby je obejæ, nale¿y wykorzystywaæ wiele
bardzo zaawansowanych i nieznanych wielu programistom metod.
Ksi¹¿ka „Jêzyk C++. Gotowe rozwi¹zania dla programistów” to podrêcznik dla tych
programistów C++, którzy zaczêli ju¿ dostrzegaæ ograniczenia tego jêzyka
i zastanawiaj¹ siê, jak sobie z nimi poradziæ. Autor pokazuje sposoby ujarzmienia
z³o¿onoci jêzyka i uzyskania pe³nej kontroli nad kodem. Przedstawia najpowa¿niejsze
wady C++ i sposoby rozwi¹zywania powodowanych przez nie problemów. Opisuje
równie¿ metody tworzenia stabilniejszego, bardziej uniwersalnego, wydajniejszego
i ³atwiejszego w pielêgnacji kodu.
• Wymuszanie za³o¿eñ projektowych
• Cykl ¿ycia obiektów
• Hermetyzacja zasobów, danych i typów
• Modele dostêpu do obiektów
• Obs³uga w¹tków
• Korzystanie z obiektów statycznych
• Konwersja danych i typów
• Zarz¹dzanie pamiêci¹
• Sterowanie dzia³aniem kompilatora
Wszyscy programici, niezale¿nie od stopnia zaawansowania, znajd¹ w tej ksi¹¿ce
wiadomoci, które usprawni¹ i przyspiesz¹ ich pracê.
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
866618831.017.png 866618831.018.png 866618831.019.png 866618831.020.png 866618831.001.png 866618831.002.png 866618831.003.png 866618831.004.png 866618831.005.png 866618831.006.png 866618831.007.png 866618831.008.png 866618831.009.png 866618831.010.png 866618831.011.png 866618831.012.png 866618831.013.png 866618831.014.png 866618831.015.png 866618831.016.png
 
Spis treci
Przedmowa .....................................................................................11
Prolog. Filozofia praktyka niedoskonałego .......................................19
Niedoskonałoci, ograniczenia, definicje i zalecenia .........................29
Cz I Podstawy ......................................................................37
Rozdział 1. Wymuszanie zało#e$ projektowych:
ograniczenia, kontrakty i asercje .....................................................39
1.1. Kilka oczywistych mdroci ............................................................................... 40
1.2. Kontrakty kompilacji — ograniczenia ................................................................ 41
1.3. Kontrakty wykonawcze: warunki wejciowe, ko#cowe i niezmienniki ............... 49
1.4. Asercje ................................................................................................................ 56
Rozdział 2. (ycie obiektów ...............................................................................67
2.1. Cykl )ycia obiektu ............................................................................................... 67
2.2. Kontrola klientów ................................................................................................ 68
2.3. Dobrodziejstwa list inicjalizacji .......................................................................... 73
Rozdział 3. Hermetyzacja zasobów ....................................................................81
3.1. Poziomy hermetyzacji zasobów .......................................................................... 81
3.2. Typy POD ........................................................................................................... 82
3.3. Porednie typy opakowujce ............................................................................... 84
3.4. Typy RRID .......................................................................................................... 87
3.5. Typy RAII ........................................................................................................... 92
3.6. RAII — podsumowanie ...................................................................................... 95
Rozdział 4. Hermetyzacja danych i typy wartoci ...............................................97
4.1. Poziomy hermetyzacji danych ............................................................................. 98
4.2. Typy wartoci a typy egzystencjalne ................................................................... 98
4.3. Klasyfikacja typów wartoci ............................................................................... 99
4.4. Typy otwarte ..................................................................................................... 101
4.5. Typy hermetyzowane ........................................................................................ 103
4.6. Typy wartoci .................................................................................................... 104
4.7. Arytmetyczne typy wartoci .............................................................................. 106
4.8. Typy wartoci — podsumowanie ...................................................................... 107
4.9. Hermetyzacja — podsumowanie ....................................................................... 107
 
6
Jzyk C++. Gotowe rozwizania dla programistów
Rozdział 5. Modele dost2pu do obiektów ........................................................113
5.1. Gwarantowany czas )ycia ................................................................................. 113
5.2. Kopia dla wywołujcego ................................................................................... 115
5.3. Oryginał dla wywołujcego ............................................................................... 116
5.4. Obiekty współdzielone ...................................................................................... 116
Rozdział 6. Zasi2g klas ..................................................................................119
6.1. Warto9 ............................................................................................................. 119
6.2. Stan ................................................................................................................... 124
6.3. API i usługi ....................................................................................................... 128
6.4. Mechanizmy j<zyka ........................................................................................... 132
Cz II Przetrwanie w wiecie rzeczywistym ............................135
Rozdział 7. ABI ..............................................................................................137
7.1. Udost<pnianie kodu ........................................................................................... 137
7.2. Wymagania ABI C ............................................................................................ 139
7.3. Wymagania ABI C++ ....................................................................................... 144
7.4. C — i wszystko jasne ........................................................................................ 148
Rozdział 8. Obiekty bez granic ........................................................................157
8.1. Czy)by przenone tabele funkcji wirtualnych? ................................................. 157
8.2. Przenone tabele vtable ..................................................................................... 161
8.3. Przenono9 — podsumowanie ......................................................................... 169
Rozdział 9. Biblioteki dynamiczne ...................................................................171
9.1. Jawne wywołania funkcji .................................................................................. 171
9.2. To)samo9 — jednostki i przestrze# konsolidacji ............................................. 174
9.3. Czas )ycia ......................................................................................................... 175
9.4. Wersjonowanie .................................................................................................. 176
9.5. Własno9 zasobów ............................................................................................ 179
9.6. Biblioteki dynamiczne — podsumowanie ......................................................... 180
Rozdział 10.W9tki ...........................................................................................181
10.1. Synchronizacja dost<pu do wartoci całkowitych ............................................. 182
10.2. Synchronizacja dost<pu do bloków kodu — regiony krytyczne ........................ 186
10.3. Wydajno9 operacji atomowych ........................................................................ 190
10.4. Rozszerzenia wielowtkowe ............................................................................. 195
10.5. TSS — składowanie danych w wtkach ............................................................ 199
Rozdział 11.Obiekty statyczne .........................................................................207
11.1. Globalne obiekty statyczne ............................................................................... 209
11.2. Singletony ......................................................................................................... 214
11.3. Lokalne obiekty statyczne funkcji ..................................................................... 222
11.4. Składowe statyczne ........................................................................................... 224
11.5. Obiekty statyczne — podsumowanie ................................................................ 227
Rozdział 12.Optymalizacja ...............................................................................229
12.1. Funkcje inline .................................................................................................... 229
12.2. Optymalizacja wartoci zwracanej ..................................................................... 231
12.3. Optymalizacja pustych klas bazowych .............................................................. 234
12.4. Optymalizacja pustych klas potomnych ............................................................ 237
12.5. Zapobieganie optymalizacji .............................................................................. 239
Spis treci
7
Cz III Kwestie jzykowe ........................................................243
Rozdział 13.Typy podstawowe .........................................................................245
13.1. Komu bajt? ........................................................................................................ 246
13.2. Typy całkowitoliczbowe o stałym rozmiarze .................................................... 249
13.3. Du)e typy całkowitoliczbowe ........................................................................... 255
13.4. Typy niebezpieczne ........................................................................................... 257
Rozdział 14.Tablice i wska;niki .......................................................................263
14.1. Nie powtarzaj si< ............................................................................................... 263
14.2. Degeneracja tablic do wskaGników ................................................................... 265
14.3. dimensionof() .................................................................................................... 268
14.4. Nie mo)na przekazywa9 tablic do funkcji ......................................................... 270
14.5. Tablice s zawsze przekazywane przez adres .................................................... 273
14.6. Tablice typów dziedziczonych .......................................................................... 274
14.7. Brak tablic wielowymiarowych ......................................................................... 281
Rozdział 15.Wartoci ......................................................................................285
15.1. NULL — słowo kluczowe, którego nie było ..................................................... 285
15.2. Spadek do zera .................................................................................................. 292
15.3. Naginanie prawdy ............................................................................................. 294
15.4. Literały .............................................................................................................. 296
15.5. Stałe .................................................................................................................. 302
Rozdział 16.Słowa kluczowe ............................................................................311
16.1. interface ............................................................................................................. 311
16.2. temporary .......................................................................................................... 314
16.3. owner ................................................................................................................. 317
16.4. explicit(_cast) .................................................................................................... 321
16.5. unique ................................................................................................................ 326
16.6. final ................................................................................................................... 327
16.7. Nieobsługiwane słowa kluczowe ...................................................................... 328
Rozdział 17.Składnia .......................................................................................331
17.1. Układ klasy ....................................................................................................... 331
17.2. Wyra)enia warunkowe ...................................................................................... 334
17.3. for ...................................................................................................................... 338
17.4. Zapis zmiennych ............................................................................................... 341
Rozdział 18.Definicja typów za pomoc9 typedef ................................................345
18.1. Definicje typu dla wskaGników ......................................................................... 347
18.2. Co wchodzi w skład definicji? .......................................................................... 349
18.3. Nowe nazwy ...................................................................................................... 354
18.4. Prawdziwe definicje typu .................................................................................. 356
18.5. Dobre, złe i brzydkie ......................................................................................... 361
Cz IV!wiadome konwersje ...................................................369
Rozdział 19.Rzutowanie ...................................................................................371
19.1. Niejawna konwersja .......................................................................................... 371
19.2. Rzutowanie w C++ ............................................................................................ 372
19.3. Przypadek rzutowania w stylu C ....................................................................... 373
19.4. Rzutowanie na sterydach ................................................................................... 375
19.5. explicit_cast ...................................................................................................... 377
19.6. literal_cast ......................................................................................................... 382
19.7. union_cast ......................................................................................................... 385
8
Jzyk C++. Gotowe rozwizania dla programistów
19.8. comstl::interface_cast ........................................................................................ 388
19.9. boost::polymorphic_cast ................................................................................... 399
19.10. Rzutowanie — podsumowanie .......................................................................... 401
Rozdział 20.Podkładki .....................................................................................403
20.1. Ogarn9 zmiany i zwi<kszy9 elastyczno9 ........................................................ 404
20.2. Podkładki atrybutów ......................................................................................... 406
20.3. Podkładki logiczne ............................................................................................ 408
20.4. Podkładki sterujce ........................................................................................... 409
20.5. Podkładki konwertujce ..................................................................................... 411
20.6. Podkładki zło)one ............................................................................................. 414
20.7. Przestrzenie nazw a sprawdzenie Koeniga ........................................................ 420
20.8. Dlaczego nie typy cechujce? ........................................................................... 423
20.9. Dopasowanie strukturalne ................................................................................. 424
20.10. Przełamywanie monolitu ................................................................................... 426
20.11. Podkładki — podsumowanie ............................................................................. 428
Rozdział 21.Forniry ..........................................................................................429
21.1. Lekkie RAII ...................................................................................................... 430
21.2. Wizanie danych z operacjami .......................................................................... 431
21.3. Przypomnienie zało)e# ..................................................................................... 438
21.4. Forniry — podsumowanie ................................................................................. 440
Rozdział 22.Sworznie ......................................................................................441
22.1. Dodawanie nowej funkcjonalnoci .................................................................... 442
22.2. Wybór skóry ...................................................................................................... 442
22.3. Przesłanianie metod niewirtualnych .................................................................. 443
22.4. Wykorzystywanie zasi<gu ................................................................................. 445
22.5. Symulowany polimorfizm czasu kompilacji — sworznie wsteczne .................. 447
22.6. Parametryzowalne pakowanie polimorficzne .................................................... 449
22.7. Sworznie — podsumowanie .............................................................................. 451
Rozdział 23.Konstruktory szablonów ................................................................453
23.1. Ukryte koszty .................................................................................................... 455
23.2. Wiszce referencje ............................................................................................ 455
23.3. Specjalizacja konstruktorów szablonów ............................................................ 457
23.4. Porednictwo argumentów ................................................................................ 458
23.5. Ukierunkowywanie na konkretne rodzaje argumentów .................................... 460
23.6. Konstruktory szablonów — podsumowanie ...................................................... 461
Cz VOperatory ....................................................................463
Rozdział 24.operator bool() .............................................................................465
24.1. operator int() const ............................................................................................ 465
24.2. operator void *() const ...................................................................................... 466
24.3. operator bool() const ......................................................................................... 467
24.4. operator !() — not! ............................................................................................ 468
24.5. operator boolean const *() const ........................................................................ 468
24.6. operator int boolean::*() const .......................................................................... 469
24.7. Stosowanie operatorów w praktyce ................................................................... 469
24.8. operator! ............................................................................................................ 473
Rozdział 25.Szybkie i nieinwazyjne ł9czenie ci9gów znaków .............................475
25.1. fast_string_concatenator<> ............................................................................... 476
25.2. Wydajno9 ......................................................................................................... 484
25.3. Praca z innymi klasami obsługujcymi cigi znaków ....................................... 487

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika:

Zgłoś jeśli naruszono regulamin