Details zum E-Book

Język C++. Kompendium wiedzy. Wydanie IV

Język C++. Kompendium wiedzy. Wydanie IV

Bjarne Stroustrup

E-book

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 772

Rozdział 27. Hierarchie szablonów 773

  • 27.1. Wprowadzenie 773
  • 27.2. Parametryzacja i hierarchia 774
    • 27.2.1. Typy generowane 776
    • 27.2.2. Konwersje szablonów 778
  • 27.3. Hierarchie szablonów klas 779
    • 27.3.1. Szablony jako interfejsy 780
  • 27.4. Parametry szablonowe jako klasy bazowe 781
    • 27.4.1. Składanie struktur danych 781
    • 27.4.2. Linearyzacja hierarchii klas 785
  • 27.5. Rady 790

Rozdział 28. Metaprogramowanie 791

  • 28.1. Wprowadzenie 791
  • 28.2. Funkcje typowe 794
    • 28.2.1. Aliasy typów 796
    • 28.2.2. Predykaty typów 798
    • 28.2.3. Wybieranie funkcji 799
    • 28.2.4. Cechy 800
  • 28.3. Struktury sterujące 802
    • 28.3.1. Wybieranie 802
    • 28.3.2. Iteracja i rekurencja 805
    • 28.3.3. Kiedy stosować metaprogramowanie 806
  • 28.4. Definicja warunkowa 807
    • 28.4.1. Używanie Enable_if 809
    • 28.4.2. Implementacja Enable_if 811
    • 28.4.3. Enable_if i koncepcje 811
    • 28.4.4. Dodatkowe przykłady użycia Enable_if 812
  • 28.5. Lista czasu kompilacji 814
    • 28.5.1. Prosta funkcja wyjściowa 816
    • 28.5.2. Dostęp do elementów 818
    • 28.5.3. make_tuple 820
  • 28.6. Szablony zmienne 821
    • 28.6.1. Bezpieczna typowo funkcja printf() 821
    • 28.6.2. Szczegóły techniczne 824
    • 28.6.3. Przekazywanie 825
    • 28.6.4. Typ tuple z biblioteki standardowej 827
  • 28.7. Przykład z jednostkami układu SI 830
    • 28.7.1. Jednostki 830
    • 28.7.2. Wielkości 831
    • 28.7.3. Literały jednostkowe 833
    • 28.7.4. Funkcje pomocnicze 834
  • 28.8. Rady 836

Rozdział 29. Projekt macierzy 837

  • 29.1. Wprowadzenie 837
    • 29.1.1. Podstawowe zastosowania macierzy 838
    • 29.1.2. Wymagania dotyczące macierzy 840
  • 29.2. Szablon macierzy 841
    • 29.2.1. Konstrukcja i przypisywanie 842
    • 29.2.2. Indeksowanie i cięcie 843
  • 29.3. Operacje arytmetyczne na macierzach 845
    • 29.3.1. Operacje skalarne 846
    • 29.3.2. Dodawanie 847
    • 29.3.3. Mnożenie 848
  • 29.4. Implementacja macierzy 850
    • 29.4.1. Wycinki 850
    • 29.4.2. Wycinki macierzy 850
    • 29.4.3. Matrix_ref 852
    • 29.4.4. Inicjacja listy macierzy 853
    • 29.4.5. Dostęp do macierzy 855
    • 29.4.6. Macierz zerowymiarowa 857
  • 29.5. Rozwiązywanie równań liniowych 858
    • 29.5.1. Klasyczna eliminacja Gaussa 859
    • 29.5.2. Znajdowanie elementu centralnego 860
    • 29.5.3. Testowanie 861
    • 29.5.4. Połączone operacje 862
  • 29.6. Rady 864

CZĘŚĆ IV. BIBLIOTEKA STANDARDOWA 865

Rozdział 30. Przegląd zawartości biblioteki standardowej 867

  • 30.1. Wprowadzenie 867
    • 30.1.1. Narzędzia biblioteki standardowej 868
    • 30.1.2. Kryteria projektowe 869
    • 30.1.3. Styl opisu 870
  • 30.2. Nagłówki 871
  • 30.3. Wsparcie dla języka 875
    • 30.3.1. Wsparcie dla list inicjacyjnych 876
    • 30.3.2. Wsparcie dla zakresowej pętli for 876
    • 30.4. Obsługa błędów 877
    • 30.4.1. Wyjątki 877
    • 30.4.2. Asercje 882
    • 30.4.3. system_error 882
  • 30.5. Rady 892

Rozdział 31. Kontenery STL 893

  • 31.1. Wprowadzenie 893
  • 31.2. Przegląd kontenerów 893
    • 31.2.1. Reprezentacja kontenera 896
    • 31.2.2. Wymagania dotyczące elementów 898
  • 31.3. Przegląd operacji 901
    • 31.3.1. Typy składowe 904
    • 31.3.2. Konstruktory, destruktory i przypisania 904
    • 31.3.3. Rozmiar i pojemność 906
    • 31.3.4. Iteratory 907
    • 31.3.5. Dostęp do elementów 908
    • 31.3.6. Operacje stosowe 908
    • 31.3.7. Operacje listowe 909
    • 31.3.8. Inne operacje 910
  • 31.4. Kontenery 910
    • 31.4.1. vector 911
    • 31.4.2. Listy 915
    • 31.4.3. Kontenery asocjacyjne 917
  • 31.5. Adaptacje kontenerów 929
    • 31.5.1. Stos 929
    • 31.5.2. Kolejka 931
    • 31.5.3. Kolejka priorytetowa 931
  • 31.6. Rady 932

Rozdział 32. Algorytmy STL 935

  • 32.1. Wprowadzenie 935
  • 32.2. Algorytmy 935
    • 32.2.1. Sekwencje 936
  • 32.3. Argumenty zasad 938
    • 32.3.1. Złożoność 939
  • 32.4. Algorytmy nie modyfikujące sekwencji 940
    • 32.4.1. for_each() 940
    • 32.4.2. Predykaty sekwencji 940
    • 32.4.3. count() 940
    • 32.4.4. find() 941
    • 32.4.5. equal() i mismatch() 942
    • 32.4.6. search() 942
  • 32.5. Algorytmy modyfikujące sekwencje 943
    • 32.5.1. copy() 944
    • 32.5.2. unique() 945
    • 32.5.3. remove() i replace() 946
    • 32.5.4. rotate(), random_shuffle() oraz partition() 947
    • 32.5.5. Permutacje 948
    • 32.5.6. fill() 948
    • 32.5.7. swap() 949
  • 32.6. Sortowanie i wyszukiwanie 950
    • 32.6.1. Wyszukiwanie binarne 952
    • 32.6.2. merge() 954
    • 32.6.3. Algorytmy działające na zbiorach 954
    • 32.6.4. Sterty 955
    • 32.6.5. lexicographical_compare() 956
  • 32.7. Element minimalny i maksymalny 957
  • 32.8. Rady 958

Rozdział 33. Iteratory STL 959

  • 33.1. Wprowadzenie 959
    • 33.1.1. Model iteratorów 959
    • 33.1.2. Kategorie iteratorów 961
    • 31.3.1. Cechy iteratorów 962
    • 33.1.4. Operacje iteratorów 964
  • 33.2. Adaptacje iteratorów 965
    • 33.2.1. Iterator odwrotny 966
    • 33.2.2. Iteratory wstawiające 968
    • 33.2.3. Iteratory przenoszące 969
  • 33.3. Zakresowe funkcje dostępowe 970
  • 33.4. Obiekty funkcyjne 971
  • Adaptacje funkcji 972
    • 33.5.1. bind() 972
    • 33.5.2. mem_fn() 974
    • 33.5.3. function 974
  • 33.6. Rady 976

Rozdział 34. Pamięć i zasoby 977

  • 34.1. Wprowadzenie 977
  • 34.2. "Prawie kontenery" 977
    • 34.2.1. array 978
    • 34.2.2. bitset 981
    • 34.2.3. vector 985
    • 34.2.4. Krotki 986
  • 34.3. Wskaźniki do zarządzania pamięcią 990
    • 34.3.1. unique_ptr 990
    • 34.3.2. shared_ptr 993
    • 34.3.3. weak_ptr 996
  • 34.4. Alokatory 998
    • 34.4.1. Alokator domyślny 1000
    • 34.4.2. Cechy alokatorów 1001
    • 34.4.3. Cechy wskaźników 1002
    • 34.4.4. Alokatory zakresowe 1003
  • 34.5. Interfejs odśmiecacza 1004
  • 34.6. Pamięć niezainicjowana 1007
    • 34.6.1. Bufory tymczasowe 1007
    • 34.6.2. raw_storage_iterator 1008
  • 34.7. Rady 1009

Rozdział 35. Narzędzia pomocnicze 1011

  • 35.1. Wprowadzenie 1011
    • 35.2. Czas 1011
    • 35.2.1. duration 1012
    • 35.5.2. time_point 1015
    • 35.2.3. Zegary 1017
    • 35.2.4. Cechy czasu 1018
  • 35.3. Działania arytmetyczne na liczbach wymiernych w czasie kompilacji 1019
  • 35.4. Funkcje typowe 1020
    • 35.4.1. Cechy typów 1020
    • 35.4.2. Generatory typów 1025
  • 35.5. Drobne narzędzia 1030
    • 35.5.1. move() i forward() 1030
    • 35.5.2. swap() 1031
    • 35.5.3. Operatory relacyjne 1031
    • 35.5.4. Porównywanie i mieszanie type_info 1032
  • 35.6. Rady 1033

Rozdział 36. Łańcuchy 1035

  • 36.1. Wprowadzenie 1035
  • 36.2. Klasyfikacja znaków 1035
    • 36.2.1. Funkcje klasyfikacji 1035
    • 36.2.2. Cechy znaków 1036
  • 36.3. Łańcuchy 1038
    • 36.3.1. Typ string a łańcuchy w stylu C 1039
    • 36.3.2. Konstruktory 1040
    • 36.3.3. Operacje podstawowe 1042
    • 36.3.4. Łańcuchowe wejście i wyjście 1044
    • 36.3.5. Konwersje numeryczne 1044
    • 36.3.6. Operacje w stylu biblioteki STL 1046
    • 36.3.7. Rodzina funkcji find 1048
    • 36.3.8. Podłańcuchy 1049
  • 36.4. Rady 1050

Rozdział 37. Wyrażenia regularne 1053

  • 37.1. Wyrażenia regularne 1053
    • 37.1.1. Notacja wyrażeń regularnych 1054
  • 37.2. regex 1059
    • 37.2.1. Wyniki dopasowywania 1061
    • 37.2.2. Formatowanie 1063
  • 37.3. Funkcje wyrażeń regularnych 1064
    • 37.3.1. regex_match() 1064
    • 37.3.2. regex_search() 1066
    • 37.3.3. regex_replace() 1067
  • 37.4. Iteratory wyrażeń regularnych 1068
    • 37.4.1. regex_iterator 1068
    • 37.4.2. regex_token_iterator 1070
  • 37.5. regex_traits 1072
  • 37.6. Rady 1073

Rozdział 38. Strumienie wejścia i wyjścia 1075

  • 38.1. Wprowadzenie 1075
  • 38.2. Hierarchia strumieni wejścia i wyjścia 1077
    • 38.2.1. Strumienie plikowe 1078
    • 38.2.2. Strumienie łańcuchowe 1079
  • 38.3. Obsługa błędów 1081
  • 38.4. Operacje wejścia i wyjścia 1082
    • 38.4.1. Operacje wejściowe 1083
    • 38.4.2. Operacje wyjściowe 1086
    • 38.4.3. Manipulatory 1088
    • 38.4.4. Stan strumienia 1089
    • 38.4.5. Formatowanie 1094
  • 38.5. Iteratory strumieniowe 1101
  • 38.6. Buforowanie 1102
    • 38.6.1. Strumienie wyjściowe i bufory 1105
    • 38.6.2. Strumienie wejściowe i bufory 1106
    • 38.6.3. Iteratory buforów 1107
  • 38.7. Rady 1109

Rozdział 39. Lokalizacje 1111

  • 39.1. Różnice kulturowe 1111
  • 39.2. Klasa locale 1114
    • 39.2.1. Lokalizacje nazwane 1116
    • 39.2.2. Porównywanie łańcuchów 1120
  • 39.3. Klasa facet 1120
    • 39.3.1. Dostęp do faset w lokalizacji 1121
    • 39.3.2. Definiowanie prostej fasety 1122
    • 39.3.3. Zastosowania lokalizacji i faset 1125
  • 39.4. Standardowe fasety 1125
    • 39.4.1. Porównywanie łańcuchów 1127
    • 39.4.2. Formatowanie liczb 1131
    • 39.4.3. Formatowanie kwot pieniężnych 1136
    • 39.4.4. Formatowanie daty i godziny 1141
    • 39.4.5. Klasyfikacja znaków 1144
    • 39.4.6. Konwersja kodów znaków 1147
    • 39.4.7. Wiadomości 1151
  • 39.5. Interfejsy pomocnicze 1155
    • 39.5.1. Klasyfikacja znaków 1155
    • 39.5.2. Konwersje znaków 1156
    • 39.5.3. Konwersje łańcuchów 1156
    • 39.5.4. Buforowanie konwersji 1157
  • 39.6. Rady 1158

Rozdział 40. Liczby 1159

  • 40.1. Wprowadzenie 1159
  • 40.2. Granice liczbowe 1160
    • 40.2.1. Makra ograniczające 1162
  • 40.3. Standardowe funkcje matematyczne 1163
  • 40.4. Liczby zespolone 1164
  • 40.5. Tablica numeryczna valarray 1166
    • 40.5.1. Konstruktory i przypisania 1166
    • 40.5.2. Indeksowanie 1168
    • 40.5.3. Operacje 1169
    • 40.5.4. Wycinki 1172
    • 40.5.5. slice_array 1174
    • 40.5.6. Uogólnione wycinki 1175
  • 40.6. Uogólnione algorytmy numeryczne 1176
    • 40.6.1. Algorytm accumulate() 1177
    • 40.6.2. Algorytm inner_product() 1177
    • 40.6.3. Algorytmy partial_sum() i adjacent_difference() 1178
    • 40.6.4. Algorytm iota() 1179
  • 40.7. Liczby losowe 1180
    • 40.7.1. Mechanizmy 1182
    • 40.7.2. Urządzenie losowe 1184
    • 40.7.3. Rozkłady 1185
    • 40.7.4. Losowanie liczb w stylu C 1189
  • 40.8. Rady 1189

Rozdział 41. Współbieżność 1191

  • 41.1. Wprowadzenie 1191
  • 41.2. Model pamięci 1193
    • 41.2.1. Lokalizacje pamięci 1194
    • 41.2.2. Zmienianie kolejności instrukcji 1195
    • 41.2.3. Porządek pamięci 1196
    • 41.2.4. Wyścigi do danych 1197
  • 41.3. Konstrukcje atomowe 1198
    • 41.3.1. Typy atomowe 1201
    • 41.3.2. Flagi i bariery 1205
  • 41.4. Słowo kluczowe volatile 1207
  • 41.5. Rady 1207

Rozdział 42. Wątki i zadania 1209

  • 42.1. Wprowadzenie 1209
  • 42.2. Wątki 1210
    • 42.2.1. Tożsamość 1211
    • 42.2.2. Konstrukcja 1212
    • 42.2.3. Destrukcja 1213
    • 42.2.4. Funkcja join() 1214
    • 42.2.5. Funkcja detach() 1215
    • 42.2.6. Przestrzeń nazw this_thread 1217
    • 42.2.7. Likwidowanie wątku 1218
    • 42.2.8. Dane lokalne wątku 1218
  • 42.3. Unikanie wyścigów do danych 1220
    • 42.3.1. Muteksy 1220
    • 42.3.2. Wiele blokad 1228
    • 42.3.3. Funkcja call_once() 1230
    • 42.3.4. Zmienne warunkowe 1231
  • 42.4. Współbieżność zadaniowa 1235
    • 42.4.1. Typy future i promise 1236
    • 42.4.2. Typ promise 1237
    • 42.4.3. Typ packaged_task 1238
    • 42.4.4. Typ future 1241
    • 42.4.5. Typ shared_future 1244
    • 42.4.6. Funkcja async() 1245
    • 42.4.7. Przykład równoległej funkcji find() 1247
  • 42.5. Rady 1251

Rozdział 43. Biblioteka standardowa C 1253

  • 43.1. Wprowadzenie 1253
  • 43.2. Pliki 1253
  • 43.3. Rodzina printf() 1254
  • 43.4. Łańcuchy w stylu C 1259
  • 43.5. Pamięć 1260
  • 43.6. Data i godzina 1261
  • 43.7. Itd. 1264
  • 43.8. Rady 1266

Rozdział 44. Zgodność 1267

  • 44.1. Wprowadzenie 1267
  • 44.2. Rozszerzenia C++11 1268
    • 44.2.1. Narzędzia językowe 1268
    • 44.2.2. Składniki biblioteki standardowej 1269
    • 44.2.3. Elementy wycofywane 1270
    • 44.2.4. Praca ze starszymi implementacjami C++ 1271
  • 44.3. Zgodność C i C++ 1271
    • 44.3.1. C i C++ to rodzeństwo 1271
    • 44.3.2. "Ciche" różnice 1273
    • 44.3.3. Kod C nie będący kodem C++ 1274
    • 44.3.4. Kod C++ nie będący kodem C 1277
  • 44.4. Rady 1279

Skorowidz 1281

  • Titel: Język C++. Kompendium wiedzy. Wydanie IV
  • Autor: Bjarne Stroustrup
  • Originaler Titel: The C++ Programming Language, 4th Edition
  • Übersetzung: Łukasz Piwko
  • ISBN: 978-83-283-8330-2, 9788328383302
  • Veröffentlichungsdatum: 2014-07-14
  • Format: E-book
  • Artikelkennung: jcppkv
  • Verleger: Helion