Język C++. Kompendium wiedzy. Wydanie 4 - ebook

Twój przewodnik po C++!

C++ dzielnie broni swojej pozycji na rynku języków programowania. Pomimo silnego naporu języka Java oraz platformy .NET wciąż jest niezastąpiony w wielu dziedzinach. Jeżeli tylko wymagana jest najwyższa wydajność, dostęp do sprzętu oraz przewidywalny czas wykonania, programiści najczęściej wybierają właśnie język C++. Ostatnia wersja standardu - oznaczona numerem 11 - pozwala na jeszcze łatwiejsze pisanie kodu oraz tworzenie szybszych i wydajniejszych programów.

Najnowsze wydanie tej cenionej książki zostało poprawione i uzupełnione o nowości z tej właśnie wersji standardu języka C++. Dowiesz się, jak korzystać ze wskaźników, liczb losowych oraz udoskonalonych kontenerów. Ponadto poznasz najlepsze zastosowanie wyrażeń lambda czy szablonów. Oprócz omówienia nowości znajdziesz tu również szczegółowy przegląd klasycznych elementów języka C++. Pętle, zmienne, tablice, instrukcje warunkowe - to tylko niektóre z omawianych zagadnień. Książka stanowi doskonały podręcznik dla początkujących programistów i świetne rozwinięcie dla programujących w języku C++ na co dzień. Przekonaj się, jak łatwo i przyjemnie możesz opanować ten popularny język oprogramowania.

Dzięki tej książce:

• poznasz nowości wprowadzone w C++ 11
• zaznajomisz się z elementami biblioteki standardowej
• opanujesz podstawowy model pamięci języka C++
• zrozumiesz model pamięci języka C++

Poznaj nowości C++ 11!

• podstawowe narzędzia, np. typy, obiekty, zakresy, pamięć, wykonywanie obliczeń i wiele więcej
• modularność oparta na przestrzeniach nazw, plikach źródłowych oraz obsłudze wyjątków
• abstrakcja w C++, tj. wykorzystanie klas, hierarchii klas oraz szablonów w programowaniu tradycyjnym, obiektowym oraz ogólnym
• biblioteka standardowa: kontenery, algorytmy, iteratory, narzędzia dodatkowe, łańcuchy, strumienia wejścia i wyjścia, lokacje, biblioteki liczbowe i wiele więcej
• szczegółowy opis podstawowego modelu pamięci języka C++

Czwarte wydanie książki pozwala na łatwe przejście na C++11 programistom, którzy do tej pory programowali przy użyciu C++98 lub w innych językach. Ponadto w książce znajduje się wiele cennych informacji nawet dla znawców standardu C++11.

Przedmowa 23

Przedmowa do wydania trzeciego 27

Przedmowa do wydania drugiego 29

Przedmowa do wydania pierwszego 31

CZĘŚĆ I. WPROWADZENIE 33

Rozdział 1. Uwagi do czytelnika 35

• 1.1. Struktura książki 35
  
  • 1.1.1. Wprowadzenie 36
  • 1.1.2. Podstawowe narzędzia 36
  • 1.1.3. Techniki abstrakcji 37
  • 1.1.4. Biblioteka standardowa 39
  • 1.1.5. Przykłady i odwołania 40
• 1.2. Projekt języka C++ 41
  
  • 1.2.1. Styl programowania 43
  • 1.2.2. Kontrola typów 46
  • 1.2.3. Zgodność z językiem C 47
  • 1.2.4. Język, biblioteki i systemy 48
• 1.3. Nauka języka C++ 50
  
  • 1.3.1. Programowanie w języku C++ 52
  • 1.3.2. Rady dla programistów C++ 53
  • 1.3.3. Rady dla programistów C 53
  • 1.3.4. Rady dla programistów języka Java 54
• 1.4. Historia 55
  
  • 1.4.1. Oś czasu 56
  • 1.4.2. Pierwsze lata 57
  • 1.4.3. Standard z 1998 r. 59
  • 1.4.4. Standard z 2011 r. 62
  • 1.4.5. Do czego jest używany język C++ 65
• 1.5. Rady 67
• 1.6. Literatura 68

Rozdział 2. Kurs języka C++. Podstawy 73

• 2.1. Wprowadzenie 73
• 2.2. Podstawy 74
  
  • 2.2.1. Witaj, świecie! 75
  • 2.2.2. Typy, zmienne i arytmetyka 76
  • 2.2.3. Stałe 78
  • 2.2.4. Testy i pętle 79
  • 2.2.5. Wskaźniki, tablice i pętle 80
• 2.3. Typy zdefiniowane przez użytkownika 82
  
  • 2.3.1. Struktury 83
  • 2.3.2. Klasy 84
  • 2.3.3. Wyliczenia 86
• 2.4. Modułowość 87
  
  • 2.4.1. Osobna kompilacja 88
  • 2.4.2. Przestrzenie nazw 89
  • 2.4.3. Obsługa błędów 90
• 2.5. Posłowie 93
• 2.6. Rady 93

Rozdział 3. Kurs języka C++. Techniki abstrakcji 95

• 3.1. Wprowadzenie 95
• 3.2. Klasy 96
  
  • 3.2.1. Typy konkretne 96
  • 3.2.2. Typy abstrakcyjne 101
  • 3.2.3. Funkcje wirtualne 103
  • 3.2.4. Hierarchie klas 104
• 3.3. Kopiowanie i przenoszenie 108
  
  • 3.3.1. Kopiowanie kontenerów 108
  • 3.3.2. Przenoszenie kontenerów 110
  • 3.3.3. Zarządzanie zasobami 112
  • 3.3.4. Tłumienie operacji 113
• 3.4. Szablony 113
  
  • 3.4.1. Typy parametryzowane 114
  • 3.4.2. Szablony funkcji 115
  • 3.4.3. Obiekty funkcyjne 116
  • 3.4.4. Zmienne szablony 118
  • 3.4.5. Aliasy 119
• 3.5. Rady 120

Rozdział 4. Kurs języka C++. Kontenery i algorytmy 121

• 4.1. Biblioteki 121
  
  • 4.1.1. Przegląd biblioteki standardowej 122
  • 4.1.2. Nagłówki i przestrzeń nazw biblioteki standardowej 123
• 4.2. Łańcuchy 124
• 4.3. Strumienie wejścia i wyjścia 126
  
  • 4.3.1. Wyjście 126
  • 4.3.2. Wejście 127
  • 4.3.3. Wejście i wyjście typów zdefiniowanych przez użytkownika 128
• 4.4. Kontenery 129
  
  • 4.4.1. vector 130
  • 4.4.2. list 133
  • 4.4.3. map 134
  • 4.4.4. unordered_map 135
  • 4.4.5. Przegląd kontenerów 135
• 4.5. Algorytmy 137
  
  • 4.5.1. Używanie iteratorów 138
  • 4.5.2. Typy iteratorów 140
  • 4.5.3. Iteratory strumieni 140
  • 4.5.4. Predykaty 142
  • 4.3.3. Przegląd algorytmów 143
  • 4.5.6. Algorytmy kontenerowe 143
• 4.6. Rady 144

Rozdział 5. Kurs języka C++. Współbieżność i narzędzia 145

• 5.1. Wprowadzenie 145
• 5.2. Zarządzanie zasobami 146
  
  • 5.2.1. unique_ptr i shared_ptr 146
• 5.3. Współbieżność 148
  
  • 5.3.1. Zadania i wątki 149
  • 5.3.2. Przekazywanie argumentów 150
  • 5.3.3. Zwracanie wyników 150
  • 5.3.4. Wspólne używanie danych 151
  • 5.3.5. Komunikacja między zadaniami 154
• 5.4. Drobne, ale przydatne narzędzia 157
  
  • 5.4.1. Czas 157
  • 5.4.2. Funkcje typowe 158
  • 5.4.3. pair i tuple 160
• 5.5. Wyrażenia regularne 161
• 5.6. Matematyka 162
  
  • 5.6.1. Funkcje i algorytmy matematyczne 162
  • 5.6.2. Liczby zespolone 163
  • 5.6.3. Liczby losowe 163
  • 5.6.4. Arytmetyka wektorów 165
  • 5.6.5. Limity liczbowe 165
• 5.7. Rady 166

CZĘŚĆ II. PODSTAWOWE NARZĘDZIA 167

Rozdział 6. Typy i deklaracje 169

• 6.1. Standard ISO języka C++ 169
  
  • 6.1.1. Implementacje 171
  • 6.1.2. Podstawowy źródłowy zestaw znaków 171
• 6.2. Typy 172
  
  • 6.2.1. Typy podstawowe 172
  • 6.2.2. Typ logiczny 173
  • 6.2.3. Typy znakowe 174
  • 6.2.4. Typy całkowitoliczbowe 179
  • 6.2.5. Typy zmiennoprzecinkowe 181
  • 6.2.6. Przedrostki i przyrostki 182
  • 6.2.7. void 183
  • 6.2.8. Rozmiary 183
  • 6.2.9. Wyrównanie 185
• 6.3. Deklaracje 186
  
  • 6.3.1. Struktura deklaracji 188
  • 6.3.2. Deklarowanie po kilka nazw 189
  • 6.3.3. Nazwy 189
  • 6.3.4. Zakres dostępności 191
  • 6.3.5. Inicjacja 194
  • 6.3.6. Dedukowanie typu: auto i decltype() 197
• 6.4. Obiekty i wartości 200
  
  • 6.4.1. Wartości lewo- i prawostronne 200
  • 6.4.2. Cykl istnienia obiektów 201
• 6.5. Aliasy typów 202
• 6.6. Rady 203

Rozdział 7. Wskaźniki, tablice i referencje 205

• 7.1. Wprowadzenie 205
• 7.2. Wskaźniki 205
  
  • 7.2.1. void* 206
  • 7.2.2. nullptr 207
• 7.3. Tablice 208
  
  • 7.3.1. Inicjatory tablic 209
  • 7.3.2. Literały łańcuchowe 210
• 7.4. Wskaźniki do tablic 213
  
  • 7.4.1. Przeglądanie tablic 214
  • 7.4.2. Tablice wielowymiarowe 217
  • 7.4.3. Przekazywanie tablic 217
• 7.5. Wskaźniki i const 220
• 7.6. Wskaźniki i własność 221
• 7.7. Referencje 222
  
  • 7.7.1. Referencje lewostronne 224
  • 7.7.2. Referencje prawostronne 227
  • 7.7.3. Referencje do referencji 229
  • 7.7.4. Wskaźniki i referencje 230
• 7.8. Rady 232

Rozdział 8. Struktury, unie i wyliczenia 233

• 8.1. Wprowadzenie 233
• 8.2. Struktury 234
  
  • 8.2.1. Układ struktur 235
  • 8.2.2. Nazwy struktur 236
  • 8.2.3. Struktury a klasy 237
  • 8.2.4. Struktury a tablice 239
  • 8.2.5. Ekwiwalencja typów 241
  • 8.2.6. Stare zwykłe dane 241
  • 8.2.7. Pola 244
• 8.3. Unie 244
  
  • 8.3.1. Unie a klasy 246
  • 8.3.2. Anonimowe unie 247
• 8.4. Wyliczenia 249
  
  • 8.4.1. Klasy wyliczeniowe 250
  • 8.4.2. Zwykłe wyliczenia 253
  • 8.4.3. Wyliczenia anonimowe 254
• 8.5. Rady 255

Rozdział 9. Instrukcje 257

• 9.1. Wprowadzenie 257
• 9.2. Zestawienie instrukcji 258
• 9.3. Deklaracje jako instrukcje 259
• 9.4. Instrukcje wyboru 260
  
  • 9.4.1. Instrukcje if 260
  • 9.4.2. Instrukcje switch 261
  • 9.4.3. Deklaracje w warunkach 264
• 9.5. Instrukcje iteracyjne 264
  
  • 9.5.1. Zakresowe instrukcje for 265
  • 9.5.2. Instrukcje for 266
  • 9.5.3. Instrukcje while 267
  • 9.5.4. Instrukcje do 267
  • 9.5.5. Kończenie pętli 268
• 9.6. Instrukcje goto 269
• 9.7. Komentarze i wcięcia 269
• 9.8. Rady 271

Rozdział 10. Wyrażenia 273

• 10.1. Wprowadzenie 273
• 10.2. Kalkulator 273
  
  • 10.2.1. Parser 274
  • 10.2.2. Wejście 278
  • 10.2.3. Wejście niskopoziomowe 282
  • 10.2.4. Obsługa błędów 283
  • 10.2.5. Sterownik 284
  • 10.2.6. Nagłówki 284
  • 10.2.7. Argumenty wiersza poleceń 285
  • 10.2.8. Uwaga na temat stylu 286
• 10.3. Zestawienie operatorów 287
  
  • 10.3.1. Wyniki 291
  • 10.3.2. Kolejność wykonywania działań 292
  • 10.3.3. Priorytety operatorów 292
  • 10.3.4. Obiekty tymczasowe 293
• 10.4. Wyrażenia stałe 295
  
  • 10.4.1. Stałe symboliczne 297
  • 10.4.2. const w wyrażeniach stałych 297
  • 10.4.3. Typy literałowe 297
  • 10.4.4. Argumenty referencyjne 298
  • 10.4.5. Wyrażenia stałe adresowe 299
• 10.5. Niejawna konwersja typów 299
  
  • 10.5.1. Promocje 300
  • 10.5.2. Konwersje 300
  • 10.5.3. Typowe konwersje arytmetyczne 303
• 10.6. Rady 304

Rozdział 11. Operacje wyboru 305

• 11.1. Różne operatory 305
  
  • 11.1.1. Operatory logiczne 305
  • 11.1.2. Bitowe operatory logiczne 306
  • 11.1.3. Wyrażenia warunkowe 307
  • 11.1.4. Inkrementacja i dekrementacja 307
• 11.2. Pamięć wolna 309
  
  • 11.2.1. Zarządzanie pamięcią 311
  • 11.2.2. Tablice 313
  • 11.2.3. Sprawdzanie dostępności miejsca w pamięci 314
  • 11.2.4. Przeciążanie operatora new 315
• 11.3. Listy 318
  
  • 11.3.1. Model implementacji 318
  • 11.3.2. Listy kwalifikowane 319
  • 11.3.3. Listy niekwalifikowane 320
• 11.4. Wyrażenia lambda 322
  
  • 11.4.1. Model implementacji 322
  • 11.4.2. Alternatywy dla lambd 323
  • 11.4.3. Lista zmiennych 325
  • 11.4.4. Wywoływanie i zwracanie wartości 329
  • 11.4.5. Typ lambdy 329
• 11.5. Jawna konwersja typów 330
  
  • 11.5.1. Konstrukcja 331
  • 11.5.2. Rzutowania nazwane 333
  • 11.5.3. Rzutowanie w stylu języka C 334
  • 11.5.4. Rzutowanie w stylu funkcyjnym 335
• 11.6. Rady 335

Rozdział 12. Funkcje 337

• 12.1. Deklarowanie funkcji 337
  
  • 12.1.1. Dlaczego funkcje 338
  • 12.1.2. Składniki deklaracji funkcji 338
  • 12.1.3. Definiowanie funkcji 339
  • 12.1.4. Zwracanie wartości 340
  • 12.1.5. Funkcje inline 342
  • 12.1.6. Funkcje constexpr 343
  • 12.1.7. Funkcje [[noreturn\ 346
  • 12.1.8. Zmienne lokalne 346
• 12.2. Przekazywanie argumentów 347
  
  • 12.2.1. Argumenty referencyjne 348
  • 12.2.2. Argumenty tablicowe 350
  • 12.2.4. Nieokreślona liczba argumentów 353
  • 12.2.5. Argumenty domyślne 356
• 12.3. Przeciążanie funkcji 358
  
  • 12.3.1. Automatyczne wybieranie przeciążonych funkcji 358
  • 12.3.2. Przeciążanie a typ zwrotny 360
  • 12.3.3. Przeciążanie a zakres 360
  • 12.3.4. Wybieranie przeciążonych funkcji z wieloma argumentami 361
  • 12.3.5. Ręczne wybieranie przeciążonej funkcji 362
• 12.4. Warunki wstępne i końcowe 362
• 12.5. Wskaźnik do funkcji 364
• 12.6. Makra 368
  
  • 12.6.1. Kompilacja warunkowa 370
  • 12.6.2. Makra predefiniowane 371
  • 12.6.3. Pragmy 372
• 12.7. Rady 372

Rozdział 13. Obsługa wyjątków 373

• 13.1. Obsługa błędów 373
  
  • 13.1.1. Wyjątki 374
  • 13.1.2. Tradycyjna obsługa błędów 376
  • 13.1.3. Niedbała obsługa błędów 377
  • 13.1.4. Alternatywne spojrzenie na wyjątki 378
  • 13.1.5. Kiedy nie można używać wyjątków 379
  • 13.1.6. Hierarchiczna obsługa błędów 380
  • 13.1.7. Wyjątki a wydajność 381
• 13.2. Gwarancje wyjątków 383
• 13.3. Zarządzanie zasobami 385
  
  • 13.3.1. Finalizacja 388
• 13.4. Egzekwowanie przestrzegania niezmienników 389
• 13.5. Zgłaszanie i przechwytywanie wyjątków 394
  
  • 13.5.1. Zgłaszanie wyjątków 394
  • 13.5.2. Przechwytywanie wyjątków 397
  • 13.5.3. Wyjątki a wątki 404
• 13.6. Implementacja wektora 405
  
  • 13.6.1. Prosty wektor 405
  • 13.6.2. Jawna reprezentacja pamięci 409
  • 13.6.3. Przypisywanie 411
  • 13.6.4. Zmienianie rozmiaru 414
• 13.7. Rady 416

Rozdział 14. Przestrzenie nazw 419

• 14.1. Kwestie dotyczące kompozycji 419
• 14.2. Przestrzenie nazw 420
  
  • 14.2.1. Bezpośrednia kwalifikacja 422
  • 14.2.2. Deklaracje using 423
  • 14.2.3. Dyrektywy using 424
  • 14.2.4. Wyszukiwanie wg argumentów 425
  • 14.2.5. Przestrzenie nazw są otwarte 427
• 14.3. Modularyzacja i interfejsy 428
  
  • 14.3.1. Przestrzenie nazw i moduły 430
  • 14.3.2. Implementacje 431
  • 14.3.3. Interfejsy i implementacje 433
• 14.4. Składanie przy użyciu przestrzeni nazw 435
  
  • 14.4.1. Wygoda a bezpieczeństwo 435
  • 14.4.2. Aliasy przestrzeni nazw 436
  • 14.4.3. Składanie przestrzeni nazw 436
  • 14.4.4. Składanie i wybieranie 438
  • 14.4.5. Przestrzenie nazw a przeciążanie 439
  • 14.4.6. Wersjonowanie 441
  • 14.4.7. Zagnieżdżanie przestrzeni nazw 443
  • 14.4.8. Anonimowe przestrzenie nazw 444
  • 14.4.9. Nagłówki języka C 444
• 14.5. Rady 445

Rozdział 15. Pliki źródłowe i programy 447

• 15.1. Rozdzielna kompilacja 447
• 15.2. Konsolidacja 448
  
  • 15.2.1. Nazwy lokalne w plikach 451
  • 15.2.2. Pliki nagłówkowe 451
  • 15.2.3. Reguła jednej definicji 453
  • 15.2.4. Nagłówki z biblioteki standardowej 455
  • 15.2.5. Konsolidacja z kodem w innym języku 456
  • 15.2.6. Konsolidacja a wskaźniki do funkcji 458
• 15.3. Używanie plików nagłówkowych 459
  
  • 15.3.1. Organizacja z jednym nagłówkiem 459
  • 15.3.2. Organizacja z wieloma nagłówkami 463
  • 15.3.3. Strażnicy dołączania 467
• 15.4. Programy 468
  
  • 15.4.1. Inicjacja zmiennych nielokalnych 469
  • 15.4.2. Inicjacja i współbieżność 470
  • 15.4.3. Zamykanie programu 470
• 15.5. Rady 472

CZĘŚĆ III. TECHNIKI ABSTRAKCJI 473

Rozdział 16. Klasy 475

• 16.1. Wprowadzenie 475
• 16.2. Podstawowe wiadomości o klasach 476
  
  • 16.2.1. Funkcje składowe 477
  • 16.2.2. Kopiowanie domyślne 478
  • 16.2.3. Kontrola dostępu 479
  • 16.2.4. Klasy i struktury 480
  • 16.2.5. Konstruktory 481
  • 16.2.6. Konstruktory explicit 483
  • 16.2.7. Inicjatory wewnątrzklasowe 485
  • 16.2.8. Wewnątrzklasowe definicje funkcji 486
  • 16.2.9. Zmienność 487
  • 16.2.10. Słowo kluczowe this 490
  • 16.2.11. Dostęp do składowych 491
  • 16.2.12. Składowe statyczne 492
  • 16.2.13. Typy składowe 494
• 16.3. Klasy konkretne 495
  
  • 16.3.1. Funkcje składowe 498
  • 16.3.2. Funkcje pomocnicze 500
  • 16.3.3. Przeciążanie operatorów 502
  • 16.3.4. Znaczenie klas konkretnych 503
• 16.4. Rady 504

Rozdział 17. Tworzenie, kasowanie, kopiowanie i przenoszenie 505

• 17.1. Wprowadzenie 505
• 17.2. Konstruktory i destruktory 507
  
  • 17.2.1. Konstruktory i niezmienniki 508
  • 17.2.2. Destruktory i zasoby 509
  • 17.2.3. Destruktory klas bazowych i składowych klas 510
  • 17.2.4. Wywoływanie konstruktorów i destruktorów 511
  • 17.2.5. Destruktory wirtualne 512
• 17.3. Inicjacja obiektów klas 513
  
  • 17.3.1. Inicjacja bez konstruktorów 513
  • 17.3.2. Inicjacja przy użyciu konstruktorów 515
  • 17.3.3. Konstruktory domyślne 517
  • 17.3.4. Konstruktory z listą inicjacyjną 519
• 17.4. Inicjacja składowych i bazy 524
  
  • 17.4.1. Inicjacja składowych 524
  • 17.4.2. Inicjatory bazy 525
  • 17.4.3. Delegowanie konstruktorów 526
  • 17.4.4. Inicjatory wewnątrzklasowe 527
  • 17.4.5. Inicjacja składowych statycznych 529
• 17.5. Kopiowanie i przenoszenie 530
  
  • 17.5.1. Kopiowanie 530
  • 17.5.2. Przenoszenie 537
• 17.6. Generowanie domyślnych operacji 541
  
  • 17.6.1. Jawne operacje domyślne 541
  • 17.6.2. Operacje domyślne 542
  • 17.6.3. Używanie operacji domyślnych 543
  • 17.6.4. Usuwanie funkcji 547
• 17.7. Rady 548

Rozdział 18. Przeciążanie operatorów 551

• 18.1. Wprowadzenie 551
• 18.2. Funkcje operatorowe 553
  
  • 18.2.1. Operatory dwu- i jednoargumentowe 554
  • 18.2.2. Predefiniowane znaczenie operatorów 555
  • 18.2.3. Operatory i typy zdefiniowane przez użytkownika 555
  • 18.2.4. Przekazywanie obiektów 556
  • 18.2.5. Operatory w przestrzeniach nazw 557
• 18.3. Typ reprezentujący liczby zespolone 559
  
  • 18.3.1. Operatory składowe i zewnętrzne 559
  • 18.3.2. Arytmetyka mieszana 560
  • 18.3.3. Konwersje 561
  • 18.3.4. Literały 564
  • 18.3.5. Funkcje dostępowe 565
  • 18.3.6. Funkcje pomocnicze 565
• 18.4. Konwersja typów 567
  
  • 18.4.1. Operatory konwersji 567
  • 18.4.2. Operatory konwersji explicit 569
  • 18.4.3. Niejednoznaczności 569
• 18.5. Rady 571

Rozdział 19. Operatory specjalne 573

• 19.1. Wprowadzenie 573
• 19.2. Operatory specjalne 573
  
  • 19.2.1. Indeksowanie 573
  • 19.2.2. Wywoływanie funkcji 574
  • 19.2.3. Dereferencja 576
  • 19.2.4. Inkrementacja i dekrementacja 578
  • 19.2.5. Alokacja i dezalokacja 580
  • 19.2.6. Literały zdefiniowane przez użytkownika 581
• 19.3. Klasa String 584
  
  • 19.3.1. Podstawowe operacje 585
  • 19.3.2. Dostęp do znaków 585
  • 19.3.3. Reprezentacja 586
  • 19.3.4. Funkcje składowe 589
  • 19.3.5. Funkcje pomocnicze 591
  • 19.3.6. Sposoby użycia 593
• 19.4. Przyjaciele 594
  
  • 19.4.1. Znajdowanie przyjaciół 596
  • 19.4.2. Przyjaciele i składowe 597
• 19.5. Rady 598

Rozdział 20. Derywacja klas 599

• 20.1. Wprowadzenie 599
• 20.2. Klasy pochodne 600
  
  • 20.2.1. Funkcje składowe 602
  • 20.2.2. Konstruktory i destruktory 604
• 20.3. Hierarchie klas 604
  
  • 20.3.1. Pola typów 605
  • 20.3.2. Funkcje wirtualne 607
  • 20.3.3. Bezpośrednia kwalifikacja 610
  • 20.3.4. Kontrola przesłaniania 610
  • 20.3.5. Używanie składowych klasy bazowej 614
  • 20.3.6. Rozluźnienie zasady dotyczącej typów zwrotnych 617
• 20.4. Klasy abstrakcyjne 619
• 20.5. Kontrola dostępu 621
  
  • 20.5.1. Składowe chronione 624
  • 20.5.2. Dostęp do klas bazowych 625
  • 20.5.3. Deklaracje using i kontrola dostępu 627
• 20.6. Wskaźniki do składowych 627
  
  • 20.6.1. Wskaźniki do funkcji składowych 628
  • 20.6.2. Wskaźniki do danych składowych 630
  • 20.6.3. Składowe bazy i klasy pochodnej 631
• 20.7. Rady 631

Rozdział 21. Hierarchie klas 633

• 21.1. Wprowadzenie 633
• 21.2. Projektowanie hierarchii klas 633
  
  • 21.2.1. Dziedziczenie implementacji 634
  • 21.2.2. Dziedziczenie interfejsu 637
  • 21.2.3. Alternatywne implementacje 639
  • 21.2.4. Lokalizowanie tworzenia obiektu 642
• 21.3. Wielodziedziczenie 644
  
  • 21.3.1. Wiele interfejsów 644
  • 21.3.2. Wiele klas implementacyjnych 644
  • 21.3.3. Rozstrzyganie niejednoznaczności 646
  • 21.3.4. Wielokrotne użycie klasy bazowej 649
  • 21.3.5. Wirtualne klasy bazowe 651
  • 21.3.6. Bazy wirtualne a replikowane 655
• 21.4. Rady 658

Rozdział 22. Informacje o typach w czasie działania programu 659

• 22.1. Wprowadzenie 659
• 22.2. Poruszanie się w obrębie hierarchii klas 660
  
  • 22.2.1. Rzutowanie dynamiczne 661
  • 22.2.2. Wielodziedziczenie 664
  • 22.2.3. Rzutowanie statyczne i dynamiczne 665
  • 22.2.4. Odzyskiwanie interfejsu 667
• 22.3. Podwójny polimorfizm i wizytatorzy 670
  
  • 22.3.1. Podwójny polimorfizm 671
  • 22.3.2. Wizytatorzy 673
• 22.4. Konstrukcja i destrukcja 675
• 22.5. Identyfikacja typów 675
  
  • 22.5.1. Rozszerzone informacje o typie 677
• 22.6. Poprawne i niepoprawne używanie RTTI 678
• 22.7. Rady 680

Rozdział 23. Szablony 681

• 23.1. Wprowadzenie i przegląd 681
• 23.2. Prosty szablon łańcucha 684
  
  • 23.2.1. Definiowanie szablonu 685
  • 23.2.2. Konkretyzacja szablonu 687
• 23.3. Kontrola typów 688
  
  • 23.3.1. Ekwiwalencja typów 689
  • 23.3.2. Wykrywanie błędów 690
• 23.4. Składowe szablonu klasy 691
  
  • 23.4.1. Dane składowe 691
  • 23.4.2. Funkcje składowe 692
  • 23.4.3. Aliasy typów składowych 692
  • 23.4.4. Składowe statyczne 692
  • 23.4.5. Typy składowe 693
  • 23.4.6. Szablony składowe 694
  • 23.4.7. Przyjaciele 698
• 23.5. Szablony funkcji 699
  
  • 23.5.1. Argumenty szablonu funkcji 701
  • 23.5.2. Dedukcja argumentów szablonu funkcji 702
  • 23.5.3. Przeciążanie szablonów funkcji 704
• 23.6. Aliasy szablonów 708
• 23.7. Organizacja kodu źródłowego 709
  
  • 23.7.1. Konsolidacja 711
• 23.8. Rady 712

Rozdział 24. Programowanie ogólne 713

• 24.1. Wprowadzenie 713
• 24.2. Algorytmy i uogólnianie 714
• 24.3. Koncepcje 718
  
  • 24.3.1. Odkrywanie koncepcji 718
  • 24.3.2. Koncepcje i ograniczenia 722
• 24.4. Konkretyzacja koncepcji 724
  
  • 24.4.1. Aksjomaty 727
  • 24.4.2. Koncepcje wieloargumentowe 728
  • 24.4.3. Koncepcje wartości 729
  • 24.4.4. Sprawdzanie ograniczeń 730
  • 24.4.5. Sprawdzanie definicji szablonu 731
• 24.5. Rady 733

Rozdział 25. Specjalizacja 735

• 25.1. Wprowadzenie 735
• 25.2. Argumenty i parametry szablonu 736
  
  • 25.2.1. Typy jako argumenty 736
  • 25.2.2. Wartości jako argumenty 738
  • 25.2.3. Operacje jako argumenty 739
  • 25.2.4. Szablony jako argumenty 742
  • 25.2.5. Domyślne argumenty szablonów 742
• 25.3. Specjalizacja 744
  
  • 25.3.1. Specjalizacja interfejsu 747
  • 25.3.2. Szablon podstawowy 748
  • 25.3.3. Porządek specjalizacji 750
  • 25.3.4. Specjalizacja szablonu funkcji 750
• 25.4. Rady 753

Rozdział 26. Konkretyzacja 755

• 26.1. Wprowadzenie 755
• 26.2. Konkretyzacja szablonu 756
  
  • 26.2.1. Kiedy konkretyzacja jest potrzebna 757
  • 26.2.2. Ręczne sterowanie konkretyzacją 758
• 26.3. Wiązanie nazw 759
  
  • 26.3.1. Nazwy zależne 761
  • 26.3.2. Wiązanie w miejscu definicji 762
  • 26.3.3. Wiązanie w miejscu konkretyzacji 763
  • 26.3.4. Wiele miejsc konkretyzacji 766
  • 26.3.5. Szablony i przestrzenie nazw 767
  • 26.3.6. Nadmiernie agresywne wyszukiwanie wg argumentów 768
  • 26.3.7. Nazwy z klas bazowych 770
• 26.4. Rady...