Język C++. Szkoła programowania. Wydanie VI - Stephen Prata

Uwaga! Sprzedaż produktu została zakończona. Sprawdź inne w tej kategorii.Opis produktu: Język C++. Szkoła programowania. Wydanie VI - Stephen Prata

Książka jest przewodnikiem programowania w języku C++. Autor w klarowny i wnikliwy sposób omawia podstawowe pojęcia i techniki programowania. Poprzez przedstawianie kolejnych zagadnień, począwszy od kodu strukturalnego, poprzez klasy i dziedziczenie, po inteligentne wskaźniki, zagłębia się w tajniki skutecznego programowania w języku C++. Rozdziały zakończone są pytaniami sprawdzającymi wraz z odpowiedziami oraz ćwiczeniami programistycznymi, dotyczącymi omawianego zagadnienia. To wydanie zostało rozszerzone o przybliżenie nowych elementów wprowadzonych w standardzie C++11. Dzięki informacjom zawartym w książce:

* poznasz nowe elementy języka, wprowadzone w standardzie C++ 11

* zaliczysz kurs programowania w języku C++

* błyskawicznie znajdziesz informacje potrzebne w codziennej pracy

* opanujesz język C++

Język C++. Szkoła programowania. Wydanie VI - Stephen Prata.Przykładowe projekty wykorzystane w książce dostępne do pobrania. Fragment książki do przeczytania on-line.

Spis treści Podziękowania (19) Wstęp (21) Rozdział 1. Zaczynamy (31)

* Nauka C++ - co nas czeka? (31)

* Pochodzenie języka C++ - krótka historia (32)

* Język C (32)

* Filozofia programowania w C (33)

* Zmiana w C++ - programowanie obiektowe (34)

* C++ i programowanie uogólnione (35)

* Pochodzenie C++ (36)

* Przenośność i standardy (37)

* Rozwój języka w liczbach (38)

* Standardy C++ w niniejszej książce (39)

* Mechanika tworzenia programu (39)

* Pisanie kodu źródłowego (40)

* Kompilacja i konsolidacja (41)

* Podsumowanie (45)

Rozdział 2. Pierwszy program w C++ (47)

* C++ - początek (47)

* Cechy funkcji main() (49)

* Komentarze w C++ (51)

* Preprocesor i plik iostream (52)

* Nazwy plików nagłówkowych (53)

* Przestrzenie nazw (53)

* Wypisywanie danych - cout (55)

* Formatowanie kodu źródłowego C++ (57)

* Instrukcje C++ (59)

* Instrukcje deklaracji i zmienne (60)

* Instrukcja przypisania (61)

* Nowa sztuczka z cout (62)

* Inne instrukcje C++ (62)

* Użycie obiektu cin (63)

* Złączanie za pomocą cout (64)

* cin i cout - klasy po raz pierwszy (64)

* Funkcje (66)

* Użycie funkcji zwracającej wartość (66)

* Odmiany funkcji (69)

* Funkcje definiowane przez użytkownika (70)

* Funkcje użytkownika zwracające wartość (73)

* Dyrektywa using w programach z wieloma funkcjami (74)

* Podsumowanie (76)

* Pytania sprawdzające (77)

* Ćwiczenia programistyczne (77)

Rozdział 3. Dane (79)

* Zmienne proste (80)

* Nazwy zmiennych (80)

* Typy całkowitoliczbowe (81)

* Typy short, int, long i long long (82)

* Typy bez znaku (87)

* Dobór właściwego typu (89)

* Literały całkowitoliczbowe (90)

* Jak C++ ustala typ stałej? (91)

* Typ char - znaki i małe liczby całkowite (92)

* Typ danych bool (100)

* Kwalifikator const (100)

* Liczby zmiennoprzecinkowe (101)

* Zapis liczb zmiennoprzecinkowych (102)

* Zmiennoprzecinkowe typy danych (103)

* Stałe zmiennoprzecinkowe (105)

* Zalety i wady liczb zmiennoprzecinkowych (105)

* Operatory arytmetyczne C++ (106)

* Kolejność działań - priorytety operatorów i łączność (107)

* Odmiany dzielenia (108)

* Operator modulo (110)

* Konwersje typów (110)

* Automatyczne deklaracje typów w C++11 (116)

* Podsumowanie (117)

* Pytania sprawdzające (117)

* Ćwiczenia programistyczne (118)

Rozdział 4. Typy złożone (121)

* Tablice w skrócie (122)

* Uwagi o programie (124)

* Inicjalizacja tablic (124)

* Inicjalizacja tablic w C++11 (125)

* Łańcuchy (126)

* Łączenie literałów napisowych (127)

* Łańcuchy w tablicy (128)

* Problemy z wprowadzaniem łańcuchów znakowych (129)

* Wczytywanie łańcuchów znakowych wierszami (130)

* Mieszanie w danych wejściowych łańcuchów i liczb (134)

* Klasa string - wprowadzenie (135)

* Inicjalizacja łańcuchów znakowych w C++11 (136)

* Przypisanie, konkatenacja i dołączanie (136)

* Inne operacje klasy string (138)

* Klasa string a wejście i wyjście (139)

* Inne odmiany literałów napisowych (141)

* Struktury (142)

* Użycie struktury w programie (143)

* Inicjalizacja struktur w C++11 (145)

* Czy w strukturze można użyć pola typu string? (146)

* Inne cechy struktur (146)

* Tablice struktur (148)

* Pola bitowe (149)

* Unie (149)

* Typy wyliczeniowe (151)

* Ustawianie wartości enumeratorów (153)

* Zakresy wartości w typach wyliczeniowych (153)

* Wskaźniki i różne drobiazgi (154)

* Deklarowanie i inicjalizacja wskaźników (156)

* Niebezpieczeństwa związane ze wskaźnikami (158)

* Wskaźniki i liczby (159)

* Użycie operatora new do alokowania pamięci (159)

* Zwalnianie pamięci za pomocą delete (161)

* Użycie new do tworzenia tablic dynamicznych (162)

* Wskaźniki, tablice i arytmetyka wskaźników (165)

* Podsumowanie informacji o wskaźnikach (168)

* Wskaźniki i łańcuchy (170)

* Użycie new do tworzenia struktur dynamicznych (174)

* Alokacja pamięci: automatyczna, statyczna i dynamiczna (177)

* Kombinacje typów (179)

* Tablice inaczej (181)

* Klasa szablonowa vector (181)

* Klasa szablonowa array (C++11) (182)

* Porównanie tablic z obiektami vector i array (183)

* Podsumowanie (184)

* Pytania sprawdzające (185)

* Ćwiczenia programistyczne (186)

Rozdział 5. Pętle i wyrażenia relacyjne (189)

* Pętle for (190)

* Elementy pętli for (191)

* Wracamy do pętli for (196)

* Zmiana wielkości kroku (198)

* Pętla for i łańcuchy znakowe (198)

* Operatory inkrementacji (++) i dekrementacji (--) (199)

* Efekty uboczne i punkty odniesienia (200)

* Formy przedrostkowe a formy przyrostkowe (201)

* Operatory inkrementacji i dekrementacji a wskaźniki (202)

* Złożone operatory przypisania (203)

* Instrukcje złożone, czyli bloki (203)

* Przecinek jako operator (i pewne sztuczki składniowe) (205)

* Wyrażenia relacyjne (208)

* Przypisania, porównania i pomyłki (208)

* Porównywanie łańcuchów w stylu C (210)

* Porównywanie obiektów klasy string (213)

* Pętla while (213)

* Uwagi o programie (215)

* Pętla for a pętla while (216)

* Chwileczkę - tworzymy pętlę opóźnienia (217)

* Pętla do while (219)

* Zakresowe pętle for (C++11) (221)

* Pętle i wprowadzanie danych tekstowych (221)

* Najprostsza wersja cin (222)

* cin.get(char) na odsiecz (223)

* Która wersja cin.get() jest lepsza? (224)

* Koniec pliku (224)

* Jeszcze inna wersja cin.get() (227)

* Pętle zagnieżdżone i dwuwymiarowe tablice (230)

* Inicjalizacja tablic dwuwymiarowych (232)

* Stosowanie tablic dwuwymiarowych (232)

* Podsumowanie (234)

* Pytania sprawdzające (234)

* Ćwiczenia programistyczne (235)

Rozdział 6. Instrukcje warunkowe i operatory logiczne (237)

* Instrukcja if (237)

* Instrukcja if else (239)

* Formatowanie instrukcji if else (241)

* Konstrukcja if else if else (241)

* Wyrażenia logiczne (243)

* Logiczny operator alternatywy - || (243)

* Logiczny operator koniunkcji - && (245)

* Ustalanie zakresu za pomocą operatora && (247)

* Operator negacji logicznej - ! (248)

* O operatorach logicznych (250)

* Zapis alternatywny (251)

* Biblioteka cctype (251)

* Operator ?: (253)

* Instrukcja switch (255)

* Użycie enumeratorów jako etykiet (258)

* switch versus if else (259)

* Instrukcje break i continue (259)

* Uwagi o programie (261)

* Pętle wczytywania liczb (262)

* Uwagi o programie (264)

* Proste wejście-wyjście z pliku (265)

* Tekstowe wejście-wyjście i pliki tekstowe (265)

* Zapis do pliku tekstowego (267)

* Odczyt danych z pliku tekstowego (270)

* Podsumowanie (274)

* Pytania sprawdzające (275)

* Ćwiczenia programistyczne (276)

Rozdział 7. Funkcje - składniki programów w C++ (279)

* Funkcje w skrócie (280)

* Definiowanie funkcji (281)

* Prototypowanie i wywoływanie funkcji (283)

* Parametry funkcji i przekazywanie przez wartość (286)

* Wiele parametrów (287)

* Jeszcze jedna funkcja dwuargumentowa (289)

* Funkcje i tablice (291)

* Jak wskaźniki umożliwiają tworzenie funkcji przetwarzających tablice? (292)

* Skutki użycia tablic jako parametrów (293)

* Dodatkowe przykłady funkcji i tablic (295)

* Funkcje korzystające z zakresów tablic (301)

* Wskaźniki i modyfikator const (302)

* Funkcje i tablice dwuwymiarowe (306)

* Funkcje i łańcuchy w stylu C (307)

* Funkcje z łańcuchami w stylu C jako parametrami (307)

* Funkcje zwracające łańcuchy w formacie C (309)

* Funkcje i struktury (310)

* Przekazywanie i zwracanie struktur (311)

* Inny przykład użycia funkcji i struktur (312)

* Przekazywanie adresu struktury (317)

* Funkcje i obiekty klasy string (318)

* Funkcje i obiekty typu array (320)

* Uwagi o programie (321)

* Rekurencja (322)

* Rekurencja w pojedynczym wywołaniu (322)

* Rekurencja w wielu wywołaniach (324)

* Wskaźniki na funkcje (325)

* Wskaźniki na funkcje - podstawy (325)

* Przykład użycia wskaźników na funkcje (327)

* Wariacje na temat wskaźników funkcji (329)

* Uproszczenie poprzez typedef (333)

* Podsumowanie (333)

* Pytania sprawdzające (334)

* Ćwiczenia programistyczne (336)

Rozdział 8. Funkcje - zagadnienia zaawansowane (339)

* Funkcje inline (339)

* Zmienne referencyjne (342)

* Tworzenie zmiennej referencyjnej (342)

* Referencje jako parametry funkcji (345)

* Właściwości referencji (348)

* Użycie referencji do struktur (352)

* Użycie referencji z obiektami (358)

* Obiekty po raz wtóry - obiekty, dziedziczenie i referencje (361)

* Kiedy korzystać z referencji jako parametrów? (364)

* Parametry domyślne (365)

* Uwagi o programie (366)

* Przeciążanie funkcji (367)

* Przykład przeciążania funkcji (370)

* Kiedy korzystać z przeciążania funkcji? (372)

* Szablony funkcji (372)

* Przeciążone szablony (375)

* Ograniczenia szablonów (377)

* Specjalizacje jawne (377)

* Konkretyzacje i specjalizacje (380)

* Którą wersję funkcji wybierze kompilator? (382)

* Ewolucja szablonów funkcji (388)

* Podsumowanie (392)

* Pytania sprawdzające (392)

* Ćwiczenia programistyczne (393)

Rozdział 9. Model pamięci i przestrzenie nazw (397)

* Kompilacja rozłączna (397)

* Czas życia, zasięg i łączenie (403)

* Zasięg i łączenie (404)

* Przydział automatyczny (404)

* Zmienne statyczne (409)

* Przydział statyczny, łączenie zewnętrzne (411)

* Specyfikatory i kwalifikatory (419)

* Łączenie a funkcje (421)

* Łączenie językowe (422)

* Kategorie przydziału a przydział dynamiczny (423)

* Przestrzenie nazw (429)

* Tradycyjne przestrzenie nazw języka C++ (429)

* Nowe mechanizmy przestrzeni nazw (431)

* Przestrzenie nazw - przykład (438)

* Przyszłość przestrzeni nazw (441)

* Podsumowanie (442)

* Pytania sprawdzające (442)

* Ćwiczenia programistyczne (445)

Rozdział 10. Obiekty i klasy (447)

* Programowanie proceduralne a programowanie obiektowe (448)

* Klasy a abstrakcje (449)

* Czym jest typ? (449)

* Klasy w języku C++ (450)

* Implementowanie metod klas (455)

* Stosowanie klas (459)

* Zmiany implementacji (461)

* Podsumowanie poznanych wiadomości (462)

* Konstruktory i destruktory (463)

* Deklarowanie i definiowanie konstruktorów (464)

* Stosowanie konstruktorów (465)

* Konstruktory domyślne (466)

* Destruktory (467)

* Ulepszenia klasy Stock (468)

* Konstruktory i destruktory - podsumowanie (475)

* Tożsamość obiektu - wskaźnik this (476)

* Tablice obiektów (482)

* Zasięg klasy (485)

* Stałe zasięgu klasy (486)

* Wyliczenia z własnym zasięgiem (C++11) (487)

* Abstrakcyjne typy danych (488)

* Podsumowanie (492)

* Pytania sprawdzające (493)

* Ćwiczenia programistyczne (493)

Rozdział 11. Stosowanie klas (497)

* Przeciążanie operatorów (498)

* Raz, dwa, trzy - próba przeciążenia operatora (499)

* Dodatkowy operator dodawania (502)

* Ograniczenia przeciążania operatorów (505)

* Jeszcze o przeciążaniu operatorów (506)

* Przyjaciele najważniejsi (509)

* Deklarowanie przyjaźni (510)

* Typowa przyjaźń - przeciążanie operatora << (512)

* Przeciążanie operatorów - metody kontra funkcje nieskładowe (518)

* Przeciążania ciąg dalszy - klasa Vector (519)

* Składowa kodująca stan obiektu (526)

* Przeciążanie operatorów arytmetycznych dla klasy Vector (528)

* Nota implementacyjna (530)

* Wektorowe błądzenie losowe (530)

* Automatyczne konwersje i rzutowanie typów klas (534)

* O programie (539)

* Funkcje konwersji (539)

* Konwersja a zaprzyjaźnienie (544)

* Podsumowanie (547)

* Pytania sprawdzające (549)

* Ćwiczenia programistyczne (549)

Rozdział 12. Klasy a dynamiczny przydział pamięci (553)

* Klasy a pamięć dynamiczna (554)

* Powtórka z pamięci dynamicznej i statyczne składowe klas (554)

* Specjalne metody klasy (562)

* W czym tkwi problem z konstruktorem kopiującym w Stringbad? (565)

* Kolejne słabości Stringbad: operatory przypisania (568)

* Nowa, ulepszona klasa - String (571)

* Nowa wersja konstruktora domyślnego (572)

* Porównywanie ciągów (573)

* Indeksowanie ciągu (574)

* Statyczne metody klasy (575)

* Dalsze przeciążanie operatora przypisania (576)

* O czym należy pamiętać, stosując new w konstruktorach? (581)

* Zalecenia i przestrogi (582)

* Kopiowanie obiektów składowa po składowej (583)

* Słów parę o zwracaniu obiektów (584)

* Zwracanie niemodyfikowalnej (const) referencji obiektu (584)

* Zwracanie modyfikowalnej (bez const) referencji do obiektu (585)

* Zwracanie obiektu przez wartość (585)

* Zwracanie przez wartość obiektu niemodyfikowalnego (const) (586)

* Wskaźniki obiektów (587)

* Jeszcze o new i delete (589)

* Wskaźniki obiektów - podsumowanie (590)

* Jeszcze o miejscowej wersji new (592)

* Powtórka z poznanych technik (596)

* Przeciążanie operatora << (596)

* Funkcje konwersji (597)

* Klasy wykorzystujące new w konstruktorach (597)

* Symulacja kolejki (598)

* Klasa kolejki (598)

* Klasa klienta (609)

* Symulacja bankomatu (612)

* Podsumowanie (616)

* Pytania sprawdzające (617)

* Ćwiczenia programistyczne (619)

Rozdział 13. Klasy i dziedziczenie (623)

* Prosta klasa bazowa (624)

* Dziedziczenie (626)

* Konstruktory - zagadnienia związane z poziomem dostępu (628)

* Korzystanie z klasy pochodnej (631)

* Relacje między klasą pochodną a bazową (633)

* Dziedziczenie - relacja jest-czymś (635)

* Polimorficzne dziedziczenie publiczne (636)

* Tworzenie klas Brass oraz BrassPlus (637)

* Wiązanie statyczne i dynamiczne (648)

* Zgodność typów wskaźnikowych i referencyjnych (648)

* Metody wirtualne i wiązanie dynamiczne (650)

* Co trzeba wiedzieć o metodach wirtualnych? (653)

* Kontrola dostępu - poziom chroniony (656)

* Abstrakcyjne klasy bazowe (657)

* Stosowanie abstrakcyjnych klas bazowych (659)

* Filozofia abstrakcyjnych klas bazowych (665)

* Dziedziczenie i dynamiczny przydział pamięci (665)

* Przypadek pierwszy - klasa pochodna bez dynamicznego przydziału pamięci (665)

* Przypadek drugi - klasa pochodna z dynamicznym przydziałem pamięci (666)

* Przykład dziedziczenia z wykorzystaniem dynamicznego przydziału pamięci oraz funkcji zaprzyjaźnionych (668)

* Projektowanie klas - przegląd zagadnień (673)

* Metody automatycznie generowane przez kompilator (673)

* Inne metody (675)

* Dziedziczenie publiczne (678)

* Metody klasy - podsumowanie (682)

* Podsumowanie (683)

* Pytania sprawdzające (683)

* Ćwiczenia programistyczne (684)

Rozdział 14. Wielokrotne użycie kodu w C++ (687)

* Klasy ze składowymi w postaci obiektów (688)

* Krótka charakterystyka klasy valarray (688)

* Projekt klasy Student (689)

* Przykładowa klasa Student (691)

* Dziedziczenie prywatne (697)

* Nowa wersja klasy Student (697)

* Dziedziczenie wielokrotne (706)

* Podwójne egzemplarze klasy Worker (711)

* Podwójne metody (714)

* Przegląd zagadnień związanych z dziedziczeniem wielokrotnym (723)

* Szablony klas (724)

* Definiowanie szablonu klasy (724)

* Korzystanie z szablonu klasy (727)

* Analiza szablonu klasy (729)

* Szablon tablicy i argumenty pozatypowe szablonu (734)

* Elastyczność szablonów (736)

* Specjalizacja szablonu (739)

* Szablony jako składowe (742)

* Szablony jako parametry (744)

* Szablony klas i zaprzyjaźnienie (746)

* Szablonowe aliasy typów (C++11) (752)

* Podsumowanie (753)

* Pytania sprawdzające (755)

* Ćwiczenia programistyczne (757)

Rozdział 15. Zaprzyjaźnienie, wyjątki i nie tylko (763)

* Zaprzyjaźnienie (763)

* Klasy zaprzyjaźnione (764)

* Zaprzyjaźnione metody klas (768)

* Inne relacje przyjaźni (771)

* Klasy zagnieżdżone (773)

* Dostęp do klas zagnieżdżonych (774)

* Zagnieżdżanie w szablonie (776)

* Wyjątki (779)

* Wywoływanie funkcji abort() (779)

* Zwracanie kodu błędu (780)

* Mechanizm wyjątków (782)

* Wyjątki w postaci obiektów (784)

* Specyfikacje wyjątków a C++11 (788)

* Rozwijanie stosu (789)

* Inne właściwości wyjątków (793)

* Klasa exception (796)

* Wyjątki, klasy i dziedziczenie (799)

* Problemy z wyjątkami (804)

* Ostrożnie z wyjątkami (807)

* RTTI (808)

* Po co nam RTTI? (808)

* Jak działa RTTI? (809)

* Operatory rzutowania typu (816)

* Podsumowanie (820)

* Pytania sprawdzające (820)

* Ćwiczenia programistyczne (822)

Rozdział 16. Klasa string oraz biblioteka STL (823)

* Klasa string (823)

* Tworzenie obiektu string (824)

* Wprowadzanie danych do obiektów string (828)

* Używanie obiektów string (830)

* Co jeszcze oferuje klasa string? (835)

* Warianty klasy string (837)

* Szablony klas inteligentnych wskaźników (837)

* Stosowanie inteligentnych wskaźników (838)

* Więcej o inteligentnych wskaźnikach (841)

* Wyższość uniqueptr nad autoptr (844)

* Wybór inteligentnego wskaźnika (845)

* Biblioteka STL (847)

* Szablon klasy vector (847)

* Metody klasy vector (849)

* Inne możliwości klasy vector (853)

* Zakresowe pętle for (C++11) (857)

* Programowanie uogólnione (858)

* Do czego potrzebne są iteratory? (858)

* Rodzaje iteratorów (862)

* Hierarchia iteratorów (865)

* Pojęcia, uściślenia i modele (866)

* Rodzaje kontenerów (872)

* Kontenery asocjacyjne (881)

* Nieuporządkowane kontenery asocjacyjne (C++11) (887)

* Obiekty funkcyjne (funktory) (887)

* Pojęcia związane z funktorami (888)

* Funktory predefiniowane (891)

* Funktory adaptowalne i adaptatory funkcji (892)

* Algorytmy (895)

* Grupy algorytmów (895)

* Ogólne właściwości algorytmów (896)

* Biblioteka STL i klasa string (897)

* Funkcje a metody kontenerów (898)

* Używanie biblioteki STL (899)

* Inne biblioteki (903)

* Klasy vector, valarray i array (903)

* Szablon initializerlist (C++11) (908)

* Stosowanie szablonu initializerlist (910)

* Uwagi do programu (911)

* Podsumowanie (911)

* Pytania sprawdzające (913)

* Ćwiczenia programistyczne (914)

Rozdział 17. Obsługa wejścia, wyjścia oraz plików (917)

* Ogólna charakterystyka obsługi wejścia-wyjścia w języku C++ (918)

* Strumienie i bufory (919)

* Strumienie i bufory a plik iostream (921)

* Przekierowanie (923)

* Realizacja operacji wyjścia z wykorzystaniem obiektu cout (924)

* Przeciążony operator << (924)

* Inne metody klasy ostream (927)

* Opróżnianie bufora wyjściowego (930)

* Formatowanie danych wyjściowych za pomocą obiektu cout (931)

* Realizacja operacji wejścia z wykorzystaniem obiektu cin (945)

* Jak operator >> obiektu cin "widzi" dane wejściowe? (947)

* Stany strumienia (949)

* Inne metody klasy istream (953)

* Pozostałe metody klasy istream (960)

* Wejście-wyjście plikowe (964)

* Proste operacje wejścia-wyjścia plikowego (965)

* Kontrola strumienia i metoda isopen() (968)

* Otwieranie wielu plików (969)

* Przetwarzanie argumentów wiersza polecenia (969)

* Tryby otwarcia pliku (971)

* Dostęp swobodny (981)

* Formatowanie wewnętrzne (988)

* Podsumowanie (991)

* Pytania sprawdzające (992)

* Ćwiczenia programistyczne (993)

Rozdział 18. Nowy standard C++ (997)

* Podsumowanie omawianych elementów C++11 (997)

* Nowe typy (997)

* Jednolita inicjalizacja (998)

* Deklaracje (999)

* nullptr (1001)

* Inteligentne wskaźniki (1002)

* Zmiany w specyfikacji wyjątków (1002)

* Jawny zasięg elementów wyliczeń (1002)

* Zmiany w klasach (1003)

* Zmiany w szablonach i bibliotece STL (1004)

* Referencje r-wartościowe (1006)

* Semantyka przeniesienia i referencje r-wartościowe (1007)

* Potrzeba semantyki przeniesienia (1007)

* Przykład przenoszenia (1008)

* Konstruktor przenoszący - wnioski (1013)

* Przypisania (1014)

* Wymuszanie przeniesienia (1015)

* Nowe elementy klas (1018)

* Specjalne metody klas (1018)

* Metody domyślne i usunięte (1019)

* Delegowanie konstruktorów (1021)

* Dziedziczenie konstruktorów (1021)

* Zarządzanie metodami wirtualnymi: ovverride i final (1023)

* Funkcje lambda (1024)

* Wskaźniki do funkcji, funktory i lambdy (1024)

* Po co nam lambdy? (1027)

* Adaptery (1030)

* Adapter function a nieefektywność szablonów (1030)

* Naprawa problemu (1032)

* Dalsze możliwości (1034)

* Szablony o zmiennej liczbie parametrów (1035)

* Pakiety parametrów szablonu i funkcji (1035)

* Rozpakowywanie pakietów (1036)

* Rekurencja w szablonach o zmiennej liczbie parametrów (1037)

* Pozostałe udogodnienia C++11 (1040)

* Programowanie współbieżne (1040)

* Uzupełnienia biblioteki (1040)

* Programowanie niskopoziomowe (1041)

* Inne (1042)

* Zmiany języka (1042)

* Projekt Boost (1043)

* TR1 (1043)

* Korzystanie z bibliotek Boost (1043)

* Co dalej? (1044)

* Podsumowanie (1045)

* Pytania sprawdzające (1046)

* Ćwiczenia programistyczne (1049)

Dodatek A Systemy liczbowe (1051)

* Liczby dziesiętne (o podstawie 10) (1051)

* Liczby całkowite ósemkowe (o podstawie 8) (1051)

* Liczby szesnastkowe (1052)

* Liczby dwójkowe (o podstawie 2) (1052)

* Zapis dwójkowy a szesnastkowy (1053)

Dodatek B Słowa zastrzeżone języka C++ (1055)

* Słowa kluczowe języka C++ (1055)

* Leksemy alternatywne (1056)

* Nazwy zastrzeżone bibliotek języka C++ (1056)

* Identyfikatory o specjalnym znaczeniu (1057)

Dodatek C Zestaw znaków ASCII (1059) Dodatek D Priorytety operatorów (1063) Dodatek E Inne operatory (1067)

* Operatory bitowe (1067)

* Operatory przesunięcia (1067)

* Bitowe operatory logiczne (1069)

* Alternatywne reprezentacje operatorów bitowych (1071)

* Kilka typowych technik wykorzystujących operatory bitowe (1072)

* Operatory wyłuskania składowych (1073)

* alignof (C++11) (1077)

* noexcept (C++11) (1078)

Dodatek F Klasa szablonowa string (1079)

* Trzynaście typów i stała (1080)

* Informacje o danych, konstruktory i różne drobiazgi (1080)

* Konstruktor domyślny (1083)

* Konstruktory operujące na klasycznych łańcuchach C (1083)

* Konstruktory operujące na fragmentach łańcuchów C (1084)

* Konstruktory operujące na referencji l-wartościowej (1084)

* Konstruktory operujące na referencji r-wartościowej (C++11) (1085)

* Konstruktory wykorzystujące n kopii znaku (1086)

* Konstruktory wykorzystujące zakres (1086)

* Konstruktor operujący na liście inicjalizującej (C++11) (1086)

* Metody zarządzające pamięcią (1087)

* Dostęp do łańcucha (1087)

* Proste przypisanie (1088)

* Przeszukiwanie łańcuchów (1089)

* Rodzina funkcji find() (1089)

* Rodzina funkcji rfind() (1089)

* Rodzina funkcji findfirstof() (1090)

* Rodzina funkcji findlastof() (1090)

* Rodzina funkcji findfirstnotof() (1091)

* Rodzina funkcji findlastnotof() (1091)

* Metody i funkcje porównania (1091)

* Modyfikatory łańcuchów (1093)

* Metody dołączania i dodawania (1093)

* Inne metody przypisania (1094)

* Metody wstawiania (1094)

* Metody usuwania (1095)

* Metody zastępowania (1095)

* Pozostałe metody modyfikujące: copy() oraz swap() (1096)

* Wejście i wyjście (1096)

Dodatek G Metody i funkcje z biblioteki STL (1099)

* STL a C++11 (1099)

* Nowe kontenery (1099)

* Zmiany w kontenerach C++98 (1100)

* Składowe wspólne dla wszystkich (lub większości) kontenerów (1101)

* Dodatkowe składowe dla kontenerów sekwencyjnych (1104)

* Dodatkowe operacje zbiorów i map (1107)

* Kontenery asocjacyjne nieporządkujące (C++11) (1109)

* Funkcje STL (1111)

* Niemodyfikujące operacje sekwencyjne (1111)

* Mutujące operacje sekwencyjne (1116)

* Operacje sortowania i pokrewne (1125)

* Operacje liczbowe (1139)

Dodatek H Wybrane pozycje książkowe i zasoby internetowe (1141)

* Wybrane pozycje książkowe (1141)

* Zasoby internetowe (1142)

Dodatek I Dostosowywanie do standardu ANSI/ISO C++ (1145)

* Unikanie nadużywania niektórych dyrektyw preprocesora (1145)

* Do definiowania stałych lepiej używać modyfikatora const niż dyrektywy #define (1145)

* Do definiowania niewielkich funkcji lepiej używać specyfikatora inline niż makrodefinicji #define (1147)

* Używanie prototypów funkcji (1148)

* Stosowanie rzutowania typów (1148)

* Poznawanie i wykorzystywanie mechanizmów języka C++ (1149)

* Używanie nowej organizacji plików nagłówkowych (1149)

* Korzystanie z przestrzeni nazw (1149)

* Używanie inteligentnych wskaźników (1150)

* Używanie klasy string (1151)

* Korzystanie z biblioteki STL (1151)

Dodatek J Odpowiedzi do pytań sprawdzających (1153) Skorowidz (1179)

O autorze

Autorem książki “Język C++. Szkoła programowania” jest Stephen Prata - nauczyciel akademicki w stopniu profesora w dziedzinie fizyki i astronomii na College Of Marcin w Kentfield w Kaliforni. Zanim prof. Prata zajął się czystym programowaniem, używał wcześniej komputerów jako narzędzi do cyfrowego modelowania gromad gwiazd. Zakres działalności dydaktycznej Stephena Praty obejmuje przede wszystkim matematykę dyskretną i programowanie, na temat którego wydał kilkanaście publikacji, w tym również “Język C++. Szkoła Programowania”.C++ - wszechstronny język programowania dla każdego

Język C++ pojawił się w użyciu w połowie lat 80. XX wieku i jest on językiem wysokopoziomowym, który stanowi rozwinięcie legendarnego już języka C, zaliczanego do języków niskopoziomowych. Na przestrzeni minionych lat, język C++ doczekał się wielu modyfikacji i unowocześnień składni pozwalających na większe wykorzystanie swojego potencjału. VI wydanie książki “Język C++. Szkoła programowania” jest przeznaczone dla wszystkich osób, które chcą poznać wszelkie tajniki dotyczące programowania w języku C++ na każdym poziomie umiejętności.