C++. Programowanie zorientowane obiektowo. Vademecum profesjonalisty (ebook)(audiobook)(audiobook)

Autor:: Nicolai M. Josuttis

Okładka książki/ebooka C++. Programowanie zorientowane obiektowo. Vademecum profesjonalisty

Okładka książki C++. Programowanie zorientowane obiektowo. Vademecum profesjonalisty

Wydawnictwo:: Helion
Ocena:: 5.5/6 Opinie: 10
Stron:: 560
Druk:: oprawa twarda

C++ jest obecnie wiodącym językiem programowania obiektowego. Jego podstawowymi zaletami w stosunku do innych języków obiektowych jest wysoka efektywność i uniwersalność. Stosowany jest do tworzenia komercyjnego oprogramowania oraz efektywnych rozwiązań złożonych problemów.

Książka krok po kroku omawia wszystkie właściwości języka i wyjaśnia sposoby ich praktycznego użycia. Przedstawione przykłady programów nie są zbyt skomplikowane, by nie odrywać Twojej uwagi od omawianych zagadnień, ale nie są też sztucznie uproszczone. Kluczowym założeniem języka C++ jest programowanie z wykorzystaniem szablonów, które umożliwiają tworzenie rozwiązań o wysokim poziomie ogólności - na przykład implementację polimorfizmu. Nicolai Josuttis omawia możliwość łączenia szablonów z programowaniem obiektowym, która decyduje o potężnych możliwościach języka C++ jako narzędzia tworzenia wydajnych programów. W tym zakresie książka wykracza daleko poza podstawy.

Wprowadzenie do C++ i programowania obiektowego
Podstawowe pojęcia języka C++
Programowanie klas
Dziedziczenie i polimorfizm
Składowe dynamiczne i statyczne
Szablony języka C++
Szczegółowe omówienie standardowej biblioteki wejścia-wyjścia

Książka ta jest idealnym podręcznikiem umożliwiającym studiowanie języka C++ w domowym zaciszu. Prezentuje ona zagadnienia podstawowe, ale w wielu przypadkach przekracza je dostarczając prawdziwie profesjonalnej wiedzy.

Wyczerpujący, szczegółowy, praktyczny i aktualny podręcznik programowania w języku C++

Oceny i opinie klientów (10)

6
(6)
5
(3)
4
(1)
3
(0)
2
(0)
1
(0)

5.5

6 oceniona przez: Paweł, 2005-10-24

Po przerobieniu tej książki nie mam wątpliwości, że Josuttis jest fachowcem w swojej dziedzinie, ponadto (co może ważniejsze) umie tę wiedzę przekazać w sposób zrozumiały. W książce można znaleźć wiele informacji wchodzących w głąb C++. Można narzekać tylko na niezbyt szeroki moim zdaniem opis biblioteki STL; autor co prawda odsyła do innej swojej książki, ale w takim razie po co zajmuje się tym tematem w tej książce...Mimo to: gorąco polecam.
6 oceniona przez: r.sajdok, 2003-12-12

Po kupnie tej książki stwierdziłem, że jest to najlepsza książka, jaką czytałem odnośnie programowania, nie tylko c++. W końcu ktoś przystępnie i fachowo opisuje owe zagadnienie wraz z konkretnymi przykładami. Książki Tego Autora kupuje w ciemno!
6 oceniona przez: Firkraag, 2007-01-15

Oceny innych mówią same za siebie. Nie wystarczy bowiem być wybitnym specjalistą, a tych w świecie C++ nie brakuje. Aby napisać tak dobry podręcznik trzeba jeszcze moim zdaniem mieć wrodzony talent dydaktyczny. Pan Stephen Prata ten talent posiada. Zdecydowanie polecam tę książkę jako pierwszą do nauki C++. Po jej lekturze i zrozumieniu, czytelnik będzie miał opanowane solidne podstawy, wszystkich paradygmatów programowania, które nowoczesne C++ udostępnia.
Ideały jednak nie istnieją, dałbym tej pozycji 6- gdybym mógł. Minus za sporą ilość literówek oraz od czasu do czasu stosowanie konwencji void main(), co jest sprzeczne ze standardem - jednak na szczęście autor sam lojalnie o tym ostrzega.
6 oceniona przez: Dariusz Siwy, 2007-03-19

Tak jak polecam Thinking in C++, tak samo tą książkę. Prezentuje wszystko co najistotniejsze w C++ (moim zdaniem). Kniga dla wszystkich ci co zaczynają dowiedzą się sporo, ci co są profesjonalistami docenią. Gorąco polecam.
6 oceniona przez: 2005-05-06

Poezja. Tylko takie lektury w szkole :)
6 oceniona przez: Rafal, 2005-08-08

Super książka, najpierw przeczytałem 3 tomy Grebosza ale później wpadła mi ta książka i przeczytałem od deski do deski, super, pozwoliła usystematyzować wszystko i wyrobić jako taki styl, nie kupowałem jej tylko wziąłem z biblioteki, ale gdybym miał kasę i chciał się nauczyć programować to wydąłbym te xx zł :)
5 oceniona przez: 2007-12-13

Książka bardzo dobra, jednak nie dla całkowicie zielonych w temacie C/C++. Nie znalazłem żadnych znaczących błędów, posiada przydatny słownik terminów używanych przy programowaniu w języku C/C++. Polecam!
5 oceniona przez: Marek Adamczyk, 2004-12-01

Świetna książka, wyjaśnia najważniejsze zagadnienia języka c++ czyli programowanie obiektowe, co czyni c++ językiem lepszym od innych :) dlatego dostała 5, a nie 6, bo w przynajmniej moim egzemplarzu brakuje jednej tabeli (strona 50).
5 oceniona przez: Roch Mikołajczyk, 2003-10-14

Bardzo przystępnie napisana i pomocna w nauce C++.
4 oceniona przez: Tomasz Janowski, 2005-09-07

Wydaje mi się, że jednak "Thinking in C++" jest lepsza - bardziej przemyślana i systematyczna. Niestety, ale w tej książce (Josuttisa), skądinąd dobrze napisanej, jest sporo literówek w przykładowych programach. Niestety, czasem są to literówki, które nie są proste do wychwycenia, a ponadto zmieniają sens przykładu! Tylko temu, że już w zasadzie znam język C++ mogę zawdzięczać, że mimo wszystko te przykłady rozumiem. Bo przecież jak można nazwać literówkę, która w wyniku brakującej litery z klasy pochodnej robi klasę podstawową i to w przykładzie, w którym jest to właśnie bardzo istotne? Myślę, że ta książka jest dobra jako drugi podręcznik do C++, a nie jest dla tych, którzy z C++ ani z C nie mieli w ogóle kontaktu. Wyjaśnienie działania wskaźników jest lakoniczne, bez pomocy w postaci książki do C może być trudno. Przykładowo, autor nie bardzo objaśniał czym jest wskaźnik do funkcji, ale używa takowych, zupełnie, jakby czytelnik jakimś cudem w międzyczasie sam sobie je objaśnił.

więcej opinii

Szczegóły książki

Tytuł oryginału:: Object-Oriented Programming in C++
Tłumaczenie:: Jaromir Senczyk
ISBN Książki drukowanej:: 83-7361-195-9, 8373611959
Data wydania książki drukowanej:: 2003-09-11
Format:: B5
Numer z katalogu:: 2092
Przykłady na ftp

Erraty / Zgłoś erratę
Kategorie:
Programowanie » C++ - Programowanie
Serie wydawnicze: Vademecum profesjonalisty

Spis treści

Przedmowa (11)

Rozdział 1. O książce (13)

1.1. Dlaczego napisałem tę książkę? (13)
1.2. Wymagania (14)
1.3. Organizacja książki (14)
1.4. W jaki sposób należy czytać książkę? (15)
1.5. Przykłady programów i dodatkowe informacje (15)

Rozdział 2. Wprowadzenie: język C++ i programowanie obiektowe (19)

2.1. Język C++ (19)

2.1.1. Kryteria projektowania (19)
2.1.2. Historia języka (20)

2.2. C++ jako język programowania obiektowego (20)

2.2.1. Obiekty, klasy i instancje (21)
2.2.2. Klasy w języku C++ (23)
2.2.3. Hermetyzacja danych (25)
2.2.4. Dziedziczenie (27)
2.2.5. Polimorfizm (28)

2.3. Inne koncepcje języka C++ (29)

2.3.1. Obsługa wyjątków (30)
2.3.2. Szablony (30)
2.3.3. Przestrzenie nazw (32)

2.4. Terminologia (32)

Rozdział 3. Podstawowe pojęcia języka C++ (35)

3.1. Pierwszy program (35)

3.1.1. "Hello, World!" (35)
3.1.2. Komentarze w języku C++ (37)
3.1.3. Funkcja main() (37)
3.1.4. Wejście i wyjście (39)
3.1.5. Przestrzenie nazw (40)
3.1.6. Podsumowanie (41)

3.2. Typy, operatory i instrukcje sterujące (41)

3.2.1. Pierwszy program, który przeprowadza obliczenia (41)
3.2.2. Typy podstawowe (44)
3.2.3. Operatory (48)
3.2.4. Instrukcje sterujące (54)
3.2.5. Podsumowanie (57)

3.3. Funkcje i moduły (58)

3.3.1. Pliki nagłówkowe (58)
3.3.2. Plik źródłowy zawierający definicję (60)
3.3.3. Plik źródłowy zawierający wywołanie funkcji (60)
3.3.4. Kompilacja i konsolidacja (61)
3.3.5. Rozszerzenia nazw plików (62)
3.3.6. Systemowe pliki nagłówkowe i biblioteki (63)
3.3.7. Preprocesor (63)
3.3.8. Przestrzenie nazw (66)
3.3.9. Słowo kluczowe static (67)
3.3.10. Podsumowanie (69)

3.4. Łańcuchy znaków (70)

3.4.1. Pierwszy przykład programu wykorzystującego łańcuchy znaków (70)
3.4.2. Kolejny przykładowy program wykorzystujący łańcuchy znaków (74)
3.4.3. Przegląd operacji na łańcuchach znaków (78)
3.4.4. Łańcuchy znaków i C-łańcuchy (79)
3.4.5. Podsumowanie (80)

3.5. Kolekcje (80)

3.5.1. Program wykorzystujący klasę vector (81)
3.5.2. Program wykorzystujący klasę deque (82)
3.5.3. Wektory i kolejki (83)
3.5.4. Iteratory (84)
3.5.5. Przykładowy program wykorzystujący listy (87)
3.5.6. Przykłady programów wykorzystujących kontenery asocjacyjne (88)
3.5.7. Algorytmy (92)
3.5.8. Algorytmy wielozakresowe (96)
3.5.9. Iteratory strumieni (98)
3.5.10. Uwagi końcowe (100)
3.5.11. Podsumowanie (101)

3.6. Obsługa wyjątków (102)

3.6.1. Powody wprowadzenia obsługi wyjątków (102)
3.6.2. Koncepcja obsługi wyjątków (104)
3.6.3. Standardowe klasy wyjątków (105)
3.6.4. Przykład obsługi wyjątku (106)
3.6.5. Obsługa nieoczekiwanych wyjątków (109)
3.6.6. Funkcje pomocnicze obsługi błędów (110)
3.6.7. Podsumowanie (111)

3.7. Wskaźniki, tablice i C-łańcuchy (112)

3.7.1. Wskaźniki (112)
3.7.2. Tablice (115)
3.7.3. C-łańcuchy (117)
3.7.4. Podsumowanie (121)

3.8. Zarządzanie pamięcią za pomocą operatorów new i delete (121)

3.8.1. Operator new (123)
3.8.2. Operator delete (123)
3.8.3. Dynamiczne zarządzanie pamięcią tablic (124)
3.8.4. Obsługa błędów związanych z operatorem new (126)
3.8.5. Podsumowanie (126)

3.9. Komunikacja ze światem zewnętrznym (126)

3.9.1. Parametry wywołania programu (126)
3.9.2. Dostęp do zmiennych środowiska (128)
3.9.3. Przerwanie działania programu (128)
3.9.4. Wywoływanie innych programów (129)
3.9.5. Podsumowanie (130)

Rozdział 4. Programowanie klas (131)

4.1. Pierwsza klasa: Fraction (131)

4.1.1. Zanim rozpoczniemy implementację (131)
4.1.2. Deklaracja klasy Fraction (134)
4.1.3. Struktura klasy (135)
4.1.4. Funkcje składowe (138)
4.1.5. Konstruktory (138)
4.1.6. Przeciążenie funkcji (140)
4.1.7. Implementacja klasy Fraction (141)
4.1.8. Wykorzystanie klasy Fraction (146)
4.1.9. Tworzenie obiektów tymczasowych (151)
4.1.10. Notacja UML (152)
4.1.11. Podsumowanie (152)

4.2. Operatory klas (153)

4.2.1. Deklaracje operatorów (153)
4.2.2. Implementacja operatorów (156)
4.2.3. Posługiwanie się operatorami (163)
4.2.4. Operatory globalne (164)
4.2.5. Ograniczenia w definiowaniu operatorów (165)
4.2.6. Specjalne właściwości niektórych operatorów (166)
4.2.7. Podsumowanie (170)

4.3. Optymalizacja efektywności kodu (170)

4.3.1. Wstępna optymalizacja klasy Fraction (171)
4.3.2. Domyślne parametry funkcji (174)
4.3.3. Funkcje rozwijane w miejscu wywołania (175)
4.3.4. Optymalizacja z perspektywy użytkownika (177)
4.3.5. Instrukcja using (178)
4.3.6. Deklaracje pomiędzy instrukcjami (179)
4.3.7. Konstruktory kopiujące (181)
4.3.8. Podsumowanie (182)

4.4. Referencje i stałe (183)

4.4.1. Konstruktory kopiujące i przekazywanie parametrów (183)
4.4.2. Referencje (184)
4.4.3. Stałe (187)
4.4.4. Stałe funkcje składowe (189)
4.4.5. Klasa Fraction wykorzystująca referencje (190)
4.4.6. Wskaźniki stałych i stałe wskaźniki (193)
4.4.7. Podsumowanie (195)

4.5. Strumienie wejścia i wyjścia (196)

4.5.1. Strumienie (196)
4.5.2. Korzystanie ze strumieni (197)
4.5.3. Stan strumienia (203)
4.5.4. Operatory wejścia i wyjścia dla typów definiowanych przez użytkownika (205)
4.5.5. Podsumowanie (214)

4.6. Klasy zaprzyjaźnione i inne typy (214)

4.6.1. Automatyczna konwersja typów (215)
4.6.2. Słowo kluczowe explicit (217)
4.6.3. Funkcje zaprzyjaźnione (217)
4.6.4. Funkcje konwersji (223)
4.6.5. Problemy automatycznej konwersji typu (225)
4.6.6. Inne zastosowania słowa kluczowego friend (227)
4.6.7. Słowo kluczowe friend i programowanie obiektowe (227)
4.6.8. Podsumowanie (228)

4.7. Obsługa wyjątków w klasach (229)

4.7.1. Powody zastosowania obsługi wyjątków w klasie Fraction (229)
4.7.2. Obsługa wyjątków w klasie Fraction (230)
4.7.3. Klasy wyjątków (237)
4.7.4. Ponowne wyrzucenie wyjątku (237)
4.7.5. Wyjątki w destruktorach (238)
4.7.6. Wyjątki i deklaracje interfejsów (238)
4.7.7. Hierarchie klas wyjątków (239)
4.7.8. Projektowanie klas wyjątków (242)
4.7.9. Wyrzucanie standardowych wyjątków (244)
4.7.10. Bezpieczeństwo wyjątków (244)
4.7.11. Podsumowanie (245)

Rozdział 5. Dziedziczenie i polimorfizm (247)

5.1. Dziedziczenie pojedyncze (249)

5.1.1. Klasa Fraction jako klasa bazowa (249)
5.1.2. Klasa pochodna RFraction (251)
5.1.3. Deklaracja klasy pochodnej RFraction (253)
5.1.4. Dziedziczenie i konstruktory (255)
5.1.5. Implementacja klas pochodnych (258)
5.1.6. Wykorzystanie klasy pochodnej (260)
5.1.7. Konstruktory obiektów klasy bazowej (262)
5.1.8. Podsumowanie (264)

5.2. Funkcje wirtualne (264)

5.2.1. Problemy z przesłanianiem funkcji (265)
5.2.2. Statyczne i dynamiczne wiązanie funkcji (267)
5.2.3. Przeciążenie i przesłanianie (271)
5.2.4. Dostęp do parametrów klasy bazowej (273)
5.2.5. Destruktory wirtualne (274)
5.2.6. Właściwe sposoby stosowania dziedziczenia (275)
5.2.7. Inne pułapki przesłaniania funkcji (279)
5.2.8. Dziedziczenie prywatne i deklaracje dostępu (281)
5.2.9. Podsumowanie (284)

5.3. Polimorfizm (285)

5.3.1. Czym jest polimorfizm? (285)
5.3.2. Polimorfizm w języku C++ (287)
5.3.3. Przykład polimorfizmu w języku C++ (288)
5.3.4. Abstrakcyjna klasa bazowa GeoObj (291)
5.3.5. Zastosowanie polimorfizmu wewnątrz klas (298)
5.3.6. Polimorfizm nie wymaga instrukcji wyboru (304)
5.3.7. Przywracanie obiektowi jego rzeczywistej klasy (304)
5.3.8. Projektowanie przez kontrakt (308)
5.3.9. Podsumowanie (309)

5.4. Dziedziczenie wielokrotne (310)

5.4.1. Przykład dziedziczenia wielokrotnego (310)
5.4.2. Wirtualne klasy bazowe (315)
5.4.3. Identyczność i adresy (318)
5.4.4. Wielokrotne dziedziczenie tej samej klasy bazowej (321)
5.4.5. Podsumowanie (321)

5.5. Pułapki projektowania z użyciem dziedziczenia (322)

5.5.1. Dziedziczenie kontra zawieranie (322)
5.5.2. Błędy projektowania: ograniczanie dziedziczenia (323)
5.5.3. Błędy projektowania: dziedziczenie zmieniające wartość (324)
5.5.4. Błędy projektowania: dziedziczenie zmieniające interpretację wartości (326)
5.5.5. Unikajmy dziedziczenia! (327)
5.5.6. Podsumowanie (327)

Rozdział 6. Składowe dynamiczne i statyczne (329)

6.1. Składowe dynamiczne (329)

6.1.1. Implementacja klasy String (329)
6.1.2. Konstruktory i składowe dynamiczne (334)
6.1.3. Implementacja konstruktora kopiującego (336)
6.1.4. Destruktory (337)
6.1.5. Implementacja operatora przypisania (337)
6.1.6. Pozostałe operatory (339)
6.1.7. Wczytywanie łańcucha klasy String (341)
6.1.8. Komercyjne implementacje klasy String (344)
6.1.9. Inne zastosowania składowych dynamicznych (346)
6.1.10. Podsumowanie (347)

6.2. Inne aspekty składowych dynamicznych (348)

6.2.1. Składowe dynamiczne w obiektach stałych (348)
6.2.2. Funkcje konwersji dla składowych dynamicznych (351)
6.2.3. Funkcje konwersji i instrukcje warunkowe (353)
6.2.4. Stałe jako zmienne (355)
6.2.5. Zapobieganie wywołaniu domyślnych operacji (357)
6.2.6. Klasy zastępcze (358)
6.2.7. Obsługa wyjątków z użyciem parametrów (361)
6.2.8. Podsumowanie (365)

6.3. Dziedziczenie i klasy o składowych dynamicznych (365)

6.3.1. Klasa CPPBook::String jak klasa bazowa (365)
6.3.2 Klasa pochodna ColString (368)
6.3.3. Dziedziczenie funkcji zaprzyjaźnionych (371)
6.3.4. Plik źródłowy klasy pochodnej ColString (373)
6.3.5. Aplikacja klasy ColString (374)
6.3.6. Dziedziczenie specjalnych funkcji dla składowych dynamicznych (375)
6.3.7. Podsumowanie (376)

6.4. Klasy zawierające klasy (376)

6.4.1. Obiekty jako składowe innych klas (377)
6.4.2. Implementacja klasy Person (377)
6.4.3. Podsumowanie (383)

6.5. Składowe statyczne i typy pomocnicze (383)

6.5.1. Statyczne składowe klas (384)
6.5.2. Deklaracje typu wewnątrz klasy (389)
6.5.3. Typy wyliczeniowe jako statyczne stałe klasy (391)
6.5.4. Klasy zagnieżdżone i klasy lokalne (392)
6.5.5. Podsumowanie (393)

Rozdział 7. Szablony (395)

7.1. Dlaczego szablony? (395)

7.1.1. Terminologia (396)

7.2. Szablony funkcji (396)

7.2.1. Definiowanie szablonów funkcji (397)
7.2.2. Wywoływanie szablonów funkcji (398)
7.2.3. Praktyczne wskazówki dotyczące używania szablonów (399)
7.2.4. Szablony i automatyczna konwersja typu (399)
7.2.5. Przeciążanie szablonów (400)
7.2.6. Zmienne lokalne (402)
7.2.7. Podsumowanie (402)

7.3. Szablony klas (403)

7.3.1. Implementacja szablonu klasy Stack (403)
7.3.2. Zastosowanie szablonu klasy Stack (406)
7.3.3. Specjalizacja szablonów klas (408)
7.3.4. Domyślne parametry szablonu (410)
7.3.5. Podsumowanie (412)

7.4. Inne parametry szablonów (412)

7.4.1. Przykład zastosowania innych parametrów szablonów (412)
7.4.2. Ograniczenia parametrów szablonów (415)
7.4.3. Podsumowanie (416)

7.5. Inne zagadnienia związane z szablonami (416)

7.5.1. Słowo kluczowe typename (416)
7.5.2. Składowe jako szablony (417)
7.5.3. Polimorfizm statyczny z użyciem szablonów (420)
7.5.4. Podsumowanie (424)

7.6. Szablony w praktyce (424)

7.6.1. Kompilacja kodu szablonu (424)
7.6.2. Obsługa błędów (429)
7.6.3. Podsumowanie (430)

Rozdział 8. Standardowa biblioteka wejścia i wyjścia w szczegółach (433)

8.1. Standardowe klasy strumieni (433)

8.1.1. Klasy strumieni i obiekty strumieni (434)
8.1.2. Stan strumienia (436)
8.1.3. Operatory standardowe (439)
8.1.4. Funkcje standardowe (440)
8.1.5. Manipulatory (443)
8.1.6. Definicje formatu (445)
8.1.7. Internacjonalizacja (455)
8.1.8. Podsumowanie (458)

8.2. Dostęp do plików (458)

8.2.1. Klasy strumieni dla plików (458)
8.2.2. Wykorzystanie klas strumieni plików (459)
8.2.3. Znaczniki plików (461)
8.2.4. Jawne otwieranie i zamykanie plików (462)
8.2.5. Swobodny dostęp do plików (463)
8.2.6. Przekierowanie standardowych kanałów do plików (466)
8.2.7. Podsumowanie (467)

8.3. Klasy strumieni łańcuchów (467)

8.3.1. Klasy strumieni łańcuchów (468)
8.3.2. Operator rzutowania leksykalnego (470)
8.3.3. Strumienie C-łańcuchów (472)
8.3.4. Podsumowanie (474)

Rozdział 9. Inne właściwości języka (475)

9.1. Dodatkowe informacje o bibliotece standardowej (475)

9.1.1. Operacje na wektorach (475)
9.1.2. Operacje wspólne dla wszystkich kontenerów STL (482)
9.1.3. Algorytmy STL (482)
9.1.4. Ograniczenia wartości numerycznych (488)
9.1.5. Podsumowanie (492)

9.2. Definiowanie specjalnych operatorów (493)

9.2.1. Inteligentne wskaźniki (493)
9.2.2. Obiekty funkcji (496)
9.2.3. Podsumowanie (500)

9.3. Inne aspekty operatorów new i delete (500)

9.3.1. Operatory new i delete, które nie wyrzucają wyjątków (500)
9.3.2. Określanie położenia obiektu (501)
9.3.3. Funkcje obsługi operatora new (501)
9.3.4. Przeciążanie operatorów new i delete (506)
9.3.5. Dodatkowe parametry operatora new (509)
9.3.6. Podsumowanie (510)

9.4. Wskaźniki funkcji i wskaźniki składowych (510)

9.4.1. Wskaźniki funkcji (510)
9.4.2. Wskaźniki składowych (511)
9.4.3. Wskaźniki składowych i zewnętrzne interfejsy (514)
9.4.4. Podsumowanie (515)

9.5. Łączenie programów w językach C i C++ (516)

9.5.1. Łączenie zewnętrzne (516)
9.5.2. Pliki nagłówkowe w językach C i C++ (517)
9.5.3. Kompilacja funkcji main() (517)
9.5.4. Podsumowanie (518)

9.6. Dodatkowe słowa kluczowe (518)

9.6.1. Unie (518)
9.6.2. Typy wyliczeniowe (519)
9.6.3. Słowo kluczowe volatile (520)
9.6.4. Podsumowanie (520)

Rozdział 10. Podsumowanie (521)

10.1. Hierarchia operatorów języka C++ (521)
10.2. Właściwości operacji klas (523)
10.3. Zasady automatycznej konwersji typów (524)
10.4. Przydatne zasady programowania i projektowania (525)

Dodatek A Bibliografia (529)

Dodatek B Słownik (533)

Skorowidz (539)

pokaż cały spis treści

C++. Programowanie zorientowane obiektowo. Vademecum profesjonalisty (ebook)(audiobook)(audiobook)

Książka

Opis książki

Oceny i opinie klientów (10)

Szczegóły książki

Spis treści

Przenieś na półkę

Dodano produkt na półkę

Usunięto produkt z półki

Przeniesiono produkt do archiwum

Przeniesiono produkt do biblioteki

C++. Programowanie zorientowane obiektowo. Vademecum profesjonalisty (ebook)(audiobook)(audiobook)

Książka

Opis książki

Oceny i opinie klientów (10)

Szczegóły książki

Spis treści

Poinformuj mnie

Twoje uwagi do kursu

Wybierz metodę płatności

Przenieś na półkę

Dodano produkt na półkę

Usunięto produkt z półki

Przeniesiono produkt do archiwum

Przeniesiono produkt do biblioteki