Katalog książek

Wydawnictwo Helion

Helion SA
ul. Kościuszki 1c
44-100 Gliwice
tel. (32) 230-98-63




© Helion 1991-2016

Lauret zaufanych opinii
C++. Programowanie zorientowane ...

C++. Programowanie zorientowane obiektowo. Vademecum profesjonalisty

Autor: 

C++. Programowanie zorientowane obiektowo. Vademecum profesjonalisty
Ocena:
   5.5/6  Opinie  (10)
Stron: 560
Ksiazka drukowana Druk (oprawa: twarda)
Wydawca: Helion

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++
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)
6
(6)
5
(3)
4
(1)
3
(0)
2
(0)
1
(0)

Liczba ocen: 10

Średnia ocena
czytelników

  


okladka
  Ocena : 6 

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.

  Ocena : 6 

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ł :)
  Ocena : 6 

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.
  Ocena : 6 

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!
  Ocena : 6 

Poezja. Tylko takie lektury w szkole :)
  Ocena : 6 

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.
  Ocena : 5 

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!
  Ocena : 5 

Ś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).
  Ocena : 5 

Bardzo przystępnie napisana i pomocna w nauce C++.
  Ocena : 4 

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ł.