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

Indeks: KSZ-05028 EAN: 9788328391529

Wydawnictwo: Helion. Tłumaczenie: Przemysław Szeremiota. Na podstawie "Język C++. Szkoła programowania. Wydanie V”. Książka jest wnikliwym przewodnikiem po programowaniu w języku C++. Pozycja w twardej oprawie.

Język C++. Szkoła programowania. Wydanie VI - Stephen Prata
99,90 zł
95,14 zł netto
Zapłać później
Czas oczekiwania: 1-2 tyg.
Chwilowo niedostępny
Producent: Helion

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ść unique_ptr nad auto_ptr (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 initializer_list (C++11) (908)
    • Stosowanie szablonu initializer_list (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 is_open() (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 find_first_of() (1090)
    • Rodzina funkcji find_last_of() (1090)
    • Rodzina funkcji find_first_not_of() (1091)
    • Rodzina funkcji find_last_not_of() (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.

Książka - Autor Stephen Prata
Książka - Wydawnictwo Helion
Tematyka C / C++ / C#
Szerokość opakowania 17 cm
Wysokość opakowania 5 cm
Głębokość opakowania 24 cm
Masa opakowania 1.64 kg

Jako pierwszy zadaj pytanie dotyczące tego produktu!

Opinie o produkcie

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

5/5

Średnia Ocena

4

Opinie Klientów
Poniższe opinie zbieramy
i weryfikujemy przy pomocy
zewnętrznego partnera Trustmate
i pochodzą z procesu pozakupowego.

Opinie:

Piotr 15.09.2023 Potwierdzony zakup
Wyróżnia się spośród innych książek w tej kategorii. Spełnia moje oczekiwania jeżeli chodzi o zawartość.
Marcin 27.12.2022 Potwierdzony zakup
Jeszcze nie przeczytałem, ale zapowiada się dobrze.
Marcin M. 22.04.2022 Potwierdzony zakup
Super
Dominik 25.09.2023 Potwierdzony zakup

Klienci którzy zakupili ten produkt kupili również:

Produkty z tej samej kategorii: