Język C++. Kompendium wiedzy. Wydanie IV
- Wydawnictwo:
- Helion
- Wydawnictwo:
- Helion
- Ocena:
- 5.2/6 Opinie: 23
- Stron:
- 1296
- Druk:
- oprawa twarda
- Dostępne formaty:
-
PDFePubMobi
![Wyłącznie](https://static01.helion.com.pl/ebookpoint/img/img_wylacznie.png)
Opis ebooka: Język C++. Kompendium wiedzy. Wydanie IV
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.
Nowy standard C++11 ułatwia precyzyjne i bezpośrednie wyrażanie myśli w kodzie źródłowym oraz pozwala pisać szybsze i bardziej wydajne programy. Projektant i pierwszy implementator języka C++, Bjarne Stroustrup dokładnie przejrzał, przeorganizował i całkowicie przepisał swój wyczerpujący przewodnik po języku C++ przeznaczony dla wszystkich tych, którzy chcą wiedzieć, jak w pełni wykorzystać jego możliwości.
W książce Język C++. Kompendium wiedzy, wydanie 4 znajdziesz drobiazgowe objaśnienia z przykładami użycia wszystkich aspektów języka C++ - poznasz dostępne w nim narzędzia, mechanizmy, biblioteki standardowe oraz najważniejsze techniki programistyczne. Stroustrup opisuje wiele przykładów użycia "czystego języka C++", które są tak dobrane, aby jednocześnie objaśniać sposoby użycia różnych narzędzi jak i zagadnienia projektowe programu. Aby ułatwić znajdowanie dodatkowych informacji, autor posłużyć się wieloma odwołaniami do dodatkowych źródeł, zarówno w obrębie książki jak i do standardu ISO.
Opis nowości języka C++ obejmuje:
- współbieżność
- wyrażenia regularne, zarządzanie zasobami, wskaźniki, liczby losowe oraz udoskonalone kontenery
- ogólną i jednorodną inicjację, uproszczone instrukcje for, semantykę przenoszenia oraz wsparcie Unicode
- lambdy, wyrażenia stałe, posługiwanie się domyślnymi wartościami klas, szablony zmienne, aliasy szablonów oraz definiowanie literałów przez użytkownika
- kwestie zgodności
![Czytelniczy kiermasz na koniec wakacji / Książki -40%, Ebooki -50%](https://static01.helion.com.pl/ebookpoint/img/promocje/bannery/19985/box_1180x419_SM_ebp_czytelniczy_kiermasz_na_koniec_wakacji_f597d2a57.jpg)
Wybrane bestsellery
-
To drugie wydanie zwięzłego przewodnika po C++ dla doświadczonych programistów, zaktualizowane do standardu C++20. Dzięki niemu zaznajomisz się z najważniejszymi elementami języka i biblioteki standardowej, koniecznymi do efektywnej pracy w takich stylach programowania jak programowanie zorientow...(47.40 zł najniższa cena z 30 dni)
47.40 zł
79.00 zł(-40%) -
Jeśli zależy Ci na tym, aby zdobyć rzetelną wiedzę i perfekcyjne umiejętności programowania z użyciem języka C++, powinieneś uczyć się od wybitnego eksperta i twórcy tego języka — Bjarne Stroustrupa, który jako pierwszy zaprojektował i zaimplementował C++. Podręcznik, który trzymasz w ręku,...(74.50 zł najniższa cena z 30 dni)
74.50 zł
149.00 zł(-50%) -
Ta książka jest idealnym wyborem dla programisty C lub C++, który chce lepiej zapoznać się z nowościami w języku C++. Jest to zwięzły i dokładny przewodnik po najważniejszych elementach języka i komponentach biblioteki standardowej z uwzględnieniem niedawno wprowadzonych udoskonaleń i udogodnień....(41.40 zł najniższa cena z 30 dni)
41.40 zł
69.00 zł(-40%) -
Dawno, dawno temu, w głębokich latach osiemdziesiątych ubiegłego wieku pewien duński informatyk zainspirowany językiem C opracował jeden z najważniejszych, najbardziej elastycznych i do dziś niezastąpionych języków programowania — C++. Dziś ten język jest wykorzystywany do tworzenia gier ko...(149.40 zł najniższa cena z 30 dni)
149.40 zł
249.00 zł(-40%) -
Unlock the power of C++ and enhance your algorithmic thinking with this course. From understanding basic operations to mastering complex structures, this course provides a structured pathway for new programmers. Start your coding journey today!
-
Kiedy myślimy o takich aplikacjach jak Maya, VirtualBox, Telegram, Spotify, Dropbox czy Google Earth, być może nie od razu znajdujemy wspólny mianownik. A jest nim framework Qt, używany przez wszystkie te znane marki. Qt powstał z myślą o programowaniu interfejsów graficznych GUI, a ze względu na...(74.50 zł najniższa cena z 30 dni)
104.30 zł
149.00 zł(-30%) -
C++ to jeden z najpopularniejszych i najpotężniejszych języków programowania. Stanowi punkt wyjścia dla wielu innych języków, które odziedziczyły po nim składnię i liczne możliwości, dzięki czemu można śmiało stwierdzić, że znajomość C++ otwiera drzwi do świata nowoczesnego programowania i jest p...(41.40 zł najniższa cena z 30 dni)
41.40 zł
69.00 zł(-40%) -
This book is a fun introduction to the world of game programming, C++20, and the OpenGL-powered SFML using four fun, fully playable games of increasing difficulty and advancing features
O autorze ebooka
Dr Bjarne Stroustrup może mówić o sobie, że jest ojcem C++: zaprojektował go i jako pierwszy zaimplementował. Jest dyrektorem działu technologicznego banku Morgan Stanley w Nowym Jorku i profesorem wizytującym w Columbia University. Wcześniej pracował w Bell Labs, AT&T Labs oraz Texas A&M University. Otrzymał wiele wyróżnień, w tym przyznawaną przez National Academy of Engineering Nagrodę Charlesa Starka Drapera. Jest członkiem National Academy of Engineering, Institute of Electrical and Electronics Engineers (IEEE) oraz Association for Computing Machinery (ACM).
Ebooka "Język C++. Kompendium wiedzy. Wydanie IV" przeczytasz na:
-
czytnikach Inkbook, Kindle, Pocketbook, Onyx Boox i innych
-
systemach Windows, MacOS i innych
-
systemach Windows, Android, iOS, HarmonyOS
-
na dowolnych urządzeniach i aplikacjach obsługujących formaty: PDF, EPub, Mobi
Masz pytania? Zajrzyj do zakładki Pomoc »
Audiobooka "Język C++. Kompendium wiedzy. Wydanie IV" posłuchasz:
-
w aplikacji Ebookpoint na Android, iOS, HarmonyOs
-
na systemach Windows, MacOS i innych
-
na dowolnych urządzeniach i aplikacjach obsługujących format MP3 (pliki spakowane w ZIP)
Masz pytania? Zajrzyj do zakładki Pomoc »
Kurs Video "Język C++. Kompendium wiedzy. Wydanie IV" zobaczysz:
-
w aplikacjach Ebookpoint i Videopoint na Android, iOS, HarmonyOs
-
na systemach Windows, MacOS i innych z dostępem do najnowszej wersji Twojej przeglądarki internetowej
Szczegóły ebooka
- Tytuł oryginału:
- The C++ Programming Language, 4th Edition
- Tłumaczenie:
- Łukasz Piwko
- ISBN Książki drukowanej:
- 978-83-283-8329-6, 9788328383296
- Data wydania książki drukowanej:
- 2014-07-14
- ISBN Ebooka:
- 978-83-283-8330-2, 9788328383302
- Data wydania ebooka:
-
2014-07-14
Data wydania ebooka często jest dniem wprowadzenia tytułu do sprzedaży i może nie być równoznaczna z datą wydania książki papierowej. Dodatkowe informacje możesz znaleźć w darmowym fragmencie. Jeśli masz wątpliwości skontaktuj się z nami sklep@ebookpoint.pl.
- Format:
- 164x239
- Numer z katalogu:
- 148770
- Rozmiar pliku Pdf:
- 8.0MB
- Rozmiar pliku ePub:
- 6.0MB
- Rozmiar pliku Mobi:
- 18.0MB
- Pobierz przykładowy rozdział PDF
- Przykłady na ftp
Ebook zawiera materiały dodatkowe, które możesz pobrać z serwera FTP - link znajdziesz na stronie redakcyjnej.
Spis treści ebooka
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
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
Rozdział 2. Kurs języka C++. Podstawy 73
Rozdział 3. Kurs języka C++. Techniki abstrakcji 95
Rozdział 4. Kurs języka C++. Kontenery i algorytmy 121
Rozdział 5. Kurs języka C++. Współbieżność i narzędzia 145
CZĘŚĆ II. PODSTAWOWE NARZĘDZIA 167
Rozdział 6. Typy i deklaracje 169
Rozdział 7. Wskaźniki, tablice i referencje 205
Rozdział 8. Struktury, unie i wyliczenia 233
Rozdział 9. Instrukcje 257
Rozdział 10. Wyrażenia 273
Rozdział 11. Operacje wyboru 305
Rozdział 12. Funkcje 337
Rozdział 13. Obsługa wyjątków 373
Rozdział 14. Przestrzenie nazw 419
Rozdział 15. Pliki źródłowe i programy 447
CZĘŚĆ III. TECHNIKI ABSTRAKCJI 473
Rozdział 16. Klasy 475
Rozdział 17. Tworzenie, kasowanie, kopiowanie i przenoszenie 505
Rozdział 18. Przeciążanie operatorów 551
Rozdział 19. Operatory specjalne 573
Rozdział 20. Derywacja klas 599
Rozdział 21. Hierarchie klas 633
Rozdział 22. Informacje o typach w czasie działania programu 659
Rozdział 23. Szablony 681
Rozdział 24. Programowanie ogólne 713
Rozdział 25. Specjalizacja 735
Rozdział 26. Konkretyzacja 755
Rozdział 27. Hierarchie szablonów 773
Rozdział 28. Metaprogramowanie 791
Rozdział 29. Projekt macierzy 837
CZĘŚĆ IV. BIBLIOTEKA STANDARDOWA 865
Rozdział 30. Przegląd zawartości biblioteki standardowej 867
Rozdział 31. Kontenery STL 893
Rozdział 32. Algorytmy STL 935
Rozdział 33. Iteratory STL 959
Rozdział 34. Pamięć i zasoby 977
Rozdział 35. Narzędzia pomocnicze 1011
Rozdział 36. Łańcuchy 1035
Rozdział 37. Wyrażenia regularne 1053
Rozdział 38. Strumienie wejścia i wyjścia 1075
Rozdział 39. Lokalizacje 1111
Rozdział 40. Liczby 1159
Rozdział 41. Współbieżność 1191
Rozdział 42. Wątki i zadania 1209
Rozdział 43. Biblioteka standardowa C 1253
Rozdział 44. Zgodność 1267
Skorowidz 1281
Oceny i opinie klientów: Język C++. Kompendium wiedzy. Wydanie IV Bjarne Stroustrup (23)
Weryfikacja opinii następuję na podstawie historii zamówień na koncie Użytkownika umieszczającego opinię. Użytkownik mógł otrzymać punkty za opublikowanie opinii uprawniające do uzyskania rabatu w ramach Programu Punktowego.
(12)
(7)
(1)
(2)
(1)
(0)
więcej opinii