Katalog książek

Bony podarunkowe

Autorzy Nowości eBooki Bestsellery Zapowiedzi Przedsprzedaż Najlepiej oceniane Druk na żądanie

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

© Helion 1991-2013

Strona główna »

Programowanie. Teoria i praktyka...

Programowanie. Teoria i praktyka z wykorzystaniem C++

Autor: Bjarne Stroustrup

Ocena:

5.5/6 Opinie (8)

Stron: 1112

Druk (oprawa: twarda)

Powiadom mnie, gdy książka będzie dostępna w druku na żądanie

Zaczerpnij wiedzę o C++ od samego twórcy języka!

Jak zacząć pracę w zintegrowanym środowisku programistycznym?
Jak profesjonalnie tworzyć programy użytkowe?
Jak korzystać z biblioteki graficznego interfejsu użytkownika?

Jeśli zależy Ci na tym, aby zdobyć rzetelną wiedzę i perfekcyjne umiejętności programowania z użyciem języka C++, powinieneś uczyć się od wybitnego eksperta i twórcy tego języka — Bjarne Stroustrupa, który jako pierwszy zaprojektował i zaimplementował C++. Podręcznik, który trzymasz w ręku, daje Ci szansę odkrycia wszelkich tajników tego języka, obszernie opisanego w międzynarodowym standardzie i obsługującego najważniejsze techniki programistyczne. C++ umożliwia pisanie wydajnego i eleganckiego kodu, a większość technik w nim stosowanych można przenieść do innych języków programowania.

Książka "Programowanie w C++. Teoria i praktyka" zawiera szczegółowy opis pojęć i technik programistycznych, a także samego języka C++, oraz przykłady kodu. Znajdziesz tu również omówienia zagadnień zaawansowanych, takich jak przetwarzanie tekstu i testowanie. Z tego podręcznika dowiesz się, na czym polega wywoływanie funkcji przeciążonych i dopasowywanie wyrażeń regularnych. Zobaczysz też, jaki powinien być standard kodowania. Poznasz sposoby projektowania klas graficznych i systemów wbudowanych, tajniki implementacji, wykorzystywania funkcji oraz indywidualizacji operacji wejścia i wyjścia. Korzystając z tego przewodnika, nauczysz się od samego mistrza pisać doskonałe, wydajne i łatwe w utrzymaniu programy.

Techniki programistyczne
Infrastruktura algorytmiczna
Biblioteka standardowa C++
Instrukcje sterujące i obsługa błędów
Implementacja i wykorzystanie funkcji
Kontrola typów
Interfejsy klas
Indywidualizacja operacji wejścia i wyjścia
Projektowanie klas graficznych
Wektory i pamięć wolna
Kontenery i iteratory
Programowanie systemów wbudowanych
Makra

Wykorzystaj wiedzę Bjarne Stroustrupa i pisz profesjonalne programy w C++!

Tytuł oryginału: Principles and Practice Using C++
Tłumaczenie: Łukasz Piwko
ISBN Książki drukowanej: 978-83-246-2233-7, 9788324622337
Data wydania książki drukowanej: 2010-03-26
Format: 172x245
Numer z katalogu: 5305
Pobierz przykładowy rozdział PDF
Przykłady na ftp
Erraty / Zgłoś erratę
Poinformuj znajomego o książce
Czytaj: opis, spis treści
Kategorie:
Programowanie » C++ - Programowanie

Wstęp (19)

Słowo do studentów (21)
Słowo do nauczycieli (22)
Pomoc (23)
Podziękowania (23)

Uwagi do czytelnika (25)

0.1. Struktura książki (26)

0.1.1. Informacje ogólne (27)
0.1.2. Ćwiczenia, praca domowa itp. (28)
0.1.3. Po przeczytaniu tej książki (29)

0.2. Filozofia nauczania i uczenia się (29)

0.2.1. Kolejność tematów (32)
0.2.2. Programowanie a język programowania (34)
0.2.3. Przenośność (34)

0.3. Programowanie a informatyka (35)
0.4. Kreatywność i rozwiązywanie problemów (35)
0.5. Uwagi dla autorów (35)
0.6. Bibliografia (36)
0.7. Noty biograficzne (37)

Bjarne Stroustrup (37)
Lawrence "Pete" Petersen (38)

Rozdział 1. Komputery, ludzie i programowanie (39)

1.1. Wstęp (40)
1.2. Oprogramowanie (40)
1.3. Ludzie (42)
1.4. Informatyka (45)
1.5. Komputery są wszędzie (46)

1.5.1. Komputery z ekranem i bez (46)
1.5.2. Transport (47)
1.5.3. Telekomunikacja (48)
1.5.4. Medycyna (50)
1.5.5. Informacja (51)
1.5.6. Sięgamy w kosmos (52)
1.5.7. I co z tego (53)

1.6. Ideały dla programistów (54)

Część I: Podstawy (61)
Rozdział 2. Witaj, świecie! (63)

2.1. Programy (64)
2.2. Klasyczny pierwszy program (64)
2.3. Kompilacja (67)
2.4. Łączenie (69)
2.5. Środowiska programistyczne (70)

Rozdział 3. Obiekty, typy i wartości (77)

3.1. Dane wejściowe (78)
3.2. Zmienne (80)
3.3. Typy danych wejściowych (81)
3.4. Operacje i operatory (82)
3.5. Przypisanie i inicjacja (85)

3.5.1. Przykład usuwania powtarzających się słów (87)

3.6. Złożone operatory przypisania (89)

3.6.1. Przykład zliczania powtarzających się słów (89)

3.7. Nazwy (90)
3.8. Typy i obiekty (92)
3.9. Kontrola typów (94)

3.9.1. Konwersje bezpieczne dla typów (95)
3.9.2. Konwersje niebezpieczne dla typów (96)

Rozdział 4. Wykonywanie obliczeń (103)

4.1. Wykonywanie obliczeń (104)
4.2. Cele i narzędzia (105)
4.3. Wyrażenia (107)

4.3.1. Wyrażenia stałe (108)
4.3.2. Operatory (109)
4.3.3. Konwersje (111)

4.4. Instrukcje (112)

4.4.1. Selekcja (113)
4.4.2. Iteracja (119)

4.5. Funkcje (122)

4.5.1. Po co zaprzątać sobie głowę funkcjami (124)
4.5.2. Deklarowanie funkcji (125)

4.6. Wektor (126)

4.6.1. Powiększanie wektora (127)
4.6.2. Przykład wczytywania liczb do programu (128)
4.6.3. Przykład z użyciem tekstu (130)

4.7. Właściwości języka (132)

Rozdział 5. Błędy (139)

5.1. Wstęp (140)
5.2. Źródła błędów (141)
5.3. Błędy kompilacji (142)

5.3.1. Błędy składni (142)
5.3.2. Błędy typów (143)
5.3.3. Nie błędy (144)

5.4. Błędy konsolidacji (145)
5.5. Błędy czasu wykonania (146)

5.5.1. Rozwiązywanie problemu przez wywołującego (147)
5.5.2. Rozwiązywanie problemu przez wywoływanego (148)
5.5.3. Raportowanie błędów (149)

5.6. Wyjątki (151)

5.6.1. Nieprawidłowe argumenty (151)
5.6.2. Błędy zakresu (152)
5.6.3. Nieprawidłowe dane wejściowe (154)
5.6.4. Błędy zawężania zakresu (156)

5.7. Błędy logiczne (157)
5.8. Szacowanie (159)
5.9. Debugowanie (161)

5.9.1. Praktyczna rada dotycząca debugowania (162)

5.10. Warunki wstępne i końcowe (165)

5.10.1. Warunki końcowe (167)

5.11. Testowanie (168)

Rozdział 6. Pisanie programu (175)

6.1. Problem (176)
6.2. Przemyślenie problemu (176)

6.2.1. Etapy rozwoju oprogramowania (177)
6.2.2. Strategia (177)

6.3. Wracając do kalkulatora (179)

6.3.1. Pierwsza próba (180)
6.3.2. Tokeny (182)
6.3.3. Implementowanie tokenów (183)
6.3.4. Używanie tokenów (185)
6.3.5. Powrót do tablicy (187)

6.4. Gramatyki (188)

6.4.1. Dygresja - gramatyka języka angielskiego (192)
6.4.2. Pisanie gramatyki (193)

6.5. Zamiana gramatyki w kod (194)

6.5.1. Implementowanie zasad gramatyki (194)
6.5.2. Wyrażenia (195)
6.5.3. Składniki (199)
6.5.4. Podstawowe elementy wyrażeń (200)

6.6. Wypróbowywanie pierwszej wersji (201)
6.7. Wypróbowywanie drugiej wersji (205)
6.8. Strumienie tokenów (206)

6.8.1. Implementacja typu Token_stream (207)
6.8.2. Wczytywanie tokenów (209)
6.8.3. Wczytywanie liczb (210)

6.9. Struktura programu (211)

Rozdział 7. Kończenie programu (217)

7.1. Wprowadzenie (218)
7.2. Wejście i wyjście (218)
7.3. Obsługa błędów (220)
7.4. Liczby ujemne (224)
7.5. Reszta z dzielenia (225)
7.6. Oczyszczanie kodu (227)

7.6.1. Stałe symboliczne (227)
7.6.2. Użycie funkcji (229)
7.6.3. Układ kodu (230)
7.6.4. Komentarze (231)

7.7. Odzyskiwanie sprawności po wystąpieniu błędu (233)
7.8. Zmienne (236)

7.8.1. Zmienne i definicje (236)
7.8.2. Wprowadzanie nazw (240)
7.8.3. Nazwy predefiniowane (242)
7.8.4. Czy to już koniec? (243)

Rozdział 8. Szczegóły techniczne - funkcje itp. (247)

8.1. Szczegóły techniczne (248)
8.2. Deklaracje i definicje (249)

8.2.1. Rodzaje deklaracji (252)
8.2.2. Deklaracje stałych i zmiennych (252)
8.2.3. Domyślna inicjacja (254)

8.3. Pliki nagłówkowe (254)
8.4. Zakres (256)
8.5. Wywoływanie i wartość zwrotna funkcji (261)

8.5.1. Deklarowanie argumentów i typu zwrotnego (261)
8.5.2. Zwracanie wartości (263)
8.5.3. Przekazywanie przez wartość (264)
8.5.4. Przekazywanie argumentów przez stałą referencję (265)
8.5.5. Przekazywanie przez referencję (267)
8.5.6. Przekazywanie przez wartość a przez referencję (269)
8.5.7. Sprawdzanie argumentów i konwersja (271)
8.5.8. Implementacja wywołań funkcji (272)

8.6. Porządek wykonywania instrukcji (276)

8.6.1. Wartościowanie wyrażeń (277)
8.6.2. Globalna inicjacja (277)

8.7. Przestrzenie nazw (279)

8.7.1. Dyrektywy i deklaracje using (280)

Rozdział 9. Szczegóły techniczne - klasy itp. (287)

9.1. Typy zdefiniowane przez użytkownika (288)
9.2. Klasy i składowe klas (289)
9.3. Interfejs i implementacja (289)
9.4. Tworzenie klas (291)

9.4.1. Struktury i funkcje (291)
9.4.2. Funkcje składowe i konstruktory (293)
9.4.3. Ukrywanie szczegółów (294)
9.4.4. Definiowanie funkcji składowych (296)
9.4.5. Odwoływanie się do bieżącego obiektu (298)
9.4.6. Raportowanie błędów (299)

9.5. Wyliczenia (300)
9.6. Przeciążanie operatorów (302)
9.7. Interfejsy klas (303)

9.7.1. Typy argumentów (304)
9.7.2. Kopiowanie (306)
9.7.3. Konstruktory domyślne (306)
9.7.4. Stałe funkcje składowe (309)
9.7.5. Składowe i funkcje pomocnicze (310)

9.8. Klasa Date (312)

Część II: Wejście i wyjście (319)
Rozdział 10. Strumienie wejścia i wyjścia (321)

10.1. Wejście i wyjście (322)
10.2. Model strumieni wejścia i wyjścia (323)
10.3. Pliki (325)
10.4. Otwieranie pliku (326)
10.5. Odczytywanie i zapisywanie plików (328)
10.6. Obsługa błędów wejścia i wyjścia (330)
10.7. Wczytywanie pojedynczej wartości (332)

10.7.1. Rozłożenie problemu na mniejsze części (334)
10.7.2. Oddzielenie warstwy komunikacyjnej od funkcji (337)

10.8. Definiowanie operatorów wyjściowych (338)
10.9. Definiowanie operatorów wejściowych (339)
10.10. Standardowa pętla wejściowa (340)
10.11. Wczytywanie pliku strukturalnego (341)

10.11.1. Reprezentacja danych w pamięci (342)
10.11.2. Odczytywanie struktur wartości (343)
10.11.3. Zmienianie reprezentacji (347)

Rozdział 11. Indywidualizacja operacji wejścia i wyjścia (353)

11.1. Regularność i nieregularność (354)
11.2. Formatowanie danych wyjściowych (354)

11.2.1. Wysyłanie na wyjście liczb całkowitych (355)
11.2.2. Przyjmowanie na wejściu liczb całkowitych (356)
11.2.3. Wysyłanie na wyjście liczb zmiennoprzecinkowych (357)
11.2.4. Precyzja (358)
11.2.5. Pola (360)

11.3. Otwieranie plików i pozycjonowanie (361)

11.3.1. Tryby otwierania plików (361)
11.3.2. Pliki binarne (362)
11.3.3. Pozycjonowanie w plikach (365)

11.4. Strumienie łańcuchowe (365)
11.5. Wprowadzanie danych wierszami (367)
11.6. Klasyfikowanie znaków (368)
11.7. Stosowanie niestandardowych separatorów (370)
11.8. Zostało jeszcze tyle do poznania (376)

Rozdział 12. Model graficzny (381)

12.1. Czemu grafika? (382)
12.2. Model graficzny (383)
12.3. Pierwszy przykład (384)
12.4. Biblioteka GUI (387)
12.5. Współrzędne (388)
12.6. Figury geometryczne (388)
12.7. Używanie klas figur geometrycznych (389)

12.7.1. Nagłówki graficzne i funkcja main (390)
12.7.2. Prawie puste okno (390)
12.7.3. Klasa Axis (392)
12.7.4. Rysowanie wykresu funkcji (394)
12.7.5. Wielokąty (394)
12.7.6. Prostokąty (395)
12.7.7. Wypełnianie kolorem (397)
12.7.8. Tekst (398)
12.7.9. Obrazy (399)
12.7.10. Jeszcze więcej grafik (400)

12.8. Uruchamianie programu (401)

12.8.1. Pliki źródłowe (402)

Rozdział 13. Klasy graficzne (407)

13.1. Przegląd klas graficznych (408)
13.2. Klasy Point i Line (410)
13.3. Klasa Lines (412)
13.4. Klasa Color (414)
13.5. Typ Line_style (416)
13.6. Typ Open_polyline (418)
13.7. Typ Closed_polyline (419)
13.8. Typ Polygon (420)
13.9. Typ Rectangle (422)
13.10. Wykorzystywanie obiektów bez nazw (426)
13.11. Typ Text (428)
13.12. Typ Circle (430)
13.13. Typ Ellipse (431)
13.14. Typ Marked_polyline (433)
13.15. Typ Marks (434)
13.16. Typ Mark (435)
13.17. Typ Image (436)

Rozdział 14. Projektowanie klas graficznych (443)

14.1. Zasady projektowania (444)

14.1.1. Typy (444)
14.1.2. Operacje (445)
14.1.3. Nazewnictwo (446)
14.1.4. Zmienność (448)

14.2. Klasa Shape (448)

14.2.1. Klasa abstrakcyjna (450)
14.2.2. Kontrola dostępu (451)
14.2.3. Rysowanie figur (454)
14.2.4. Kopiowanie i zmienność (456)

14.3. Klasy bazowe i pochodne (458)

14.3.1. Układ obiektu (459)
14.3.2. Tworzenie podklas i definiowanie funkcji wirtualnych (461)
14.3.3. Przesłanianie (461)
14.3.4. Dostęp (463)
14.3.5. Czyste funkcje wirtualne (464)

14.4. Zalety programowania obiektowego (465)

Rozdział 15. Graficzne przedstawienie funkcji i danych (471)

15.1. Wprowadzenie (472)
15.2. Rysowanie wykresów prostych funkcji (472)
15.3. Typ Function (476)

15.3.1. Argumenty domyślne (477)
15.3.2. Więcej przykładów (478)

15.4. Typ Axis (479)
15.5. Wartość przybliżona funkcji wykładniczej (481)
15.6. Przedstawianie danych na wykresach (486)

15.6.1. Odczyt danych z pliku (487)
15.6.2. Układ ogólny (488)
15.6.3. Skalowanie danych (489)
15.6.4. Budowanie wykresu (490)

Rozdział 16. Graficzne interfejsy użytkownika (497)

16.1. Różne rodzaje interfejsów użytkownika (498)
16.2. Przycisk Next (499)
16.3. Proste okno (500)

16.3.1. Funkcje zwrotne (501)
16.3.2. Pętla oczekująca (504)

16.4. Typ Button i inne pochodne typu Widget (505)

16.4.1. Widgety (505)
16.4.2. Przyciski (506)
16.4.3. Widgety In_box i Out_box (507)
16.4.4. Menu (507)

16.5. Przykład (508)
16.6. Inwersja kontroli (511)
16.7. Dodawanie menu (513)
16.8. Debugowanie kodu GUI (517)

Część III: Dane i algorytmy (523)
Rozdział 17. Wektory i pamięć wolna (525)

17.1. Wprowadzenie (526)
17.2. Podstawowe wiadomości na temat typu vector (527)
17.3. Pamięć, adresy i wskaźniki (529)

17.3.1. Operator sizeof (531)

17.4. Pamięć wolna a wskaźniki (532)

17.4.1. Alokacja obiektów w pamięci wolnej (533)
17.4.2. Dostęp poprzez wskaźniki (534)
17.4.3. Zakresy (535)
17.4.4. Inicjacja (536)
17.4.5. Wskaźnik zerowy (537)
17.4.6. Dealokacja pamięci wolnej (538)

17.5. Destruktory (540)

17.5.1. Generowanie destruktorów (542)
17.5.2. Destruktory a pamięć wolna (542)

17.6. Dostęp do elementów (544)
17.7. Wskaźniki na obiekty klas (545)
17.8. Babranie się w typach - void* i rzutowanie (546)
17.9. Wskaźniki i referencje (548)

17.9.1. Wskaźniki i referencje jako parametry (549)
17.9.2. Wskaźniki, referencje i dziedziczenie (550)
17.9.3. Przykład - listy (551)
17.9.4. Operacje na listach (552)
17.9.5. Zastosowania list (554)

17.10. Wskaźnik this (555)

17.10.1. Więcej przykładów użycia typu Link (557)

Rozdział 18. Wektory i tablice (563)

18.1. Wprowadzenie (564)
18.2. Kopiowanie (564)

18.2.1. Konstruktory kopiujące (566)
18.2.2. Przypisywanie z kopiowaniem (567)
18.2.3. Terminologia związana z kopiowaniem (569)

18.3. Podstawowe operacje (570)

18.3.1. Konstruktory jawne (571)
18.3.2. Debugowanie konstruktorów i destruktorów (573)

18.4. Uzyskiwanie dostępu do elementów wektora (575)

18.4.1. Problem stałych wektorów (576)

18.5. Tablice (577)

18.5.1. Wskaźniki na elementy tablicy (578)
18.5.2. Wskaźniki i tablice (580)
18.5.3. Inicjowanie tablic (582)
18.5.4. Problemy ze wskaźnikami (583)

18.6. Przykłady - palindrom (586)

18.6.1. Wykorzystanie łańcuchów (586)
18.6.2. Wykorzystanie tablic (587)
18.6.3. Wykorzystanie wskaźników (588)

Rozdział 19. Wektory, szablony i wyjątki (593)

19.1. Analiza problemów (594)
19.2. Zmienianie rozmiaru (596)

19.2.1. Reprezentacja (597)
19.2.2. Rezerwacja pamięci i pojemność kontenera (598)
19.2.3. Zmienianie rozmiaru (599)
19.2.4. Funkcja push_back() (599)
19.2.5. Przypisywanie (600)
19.2.6. Podsumowanie dotychczasowej pracy nad typem vector (601)

19.3. Szablony (602)

19.3.1. Typy jako parametry szablonów (603)
19.3.2. Programowanie ogólne (605)
19.3.3. Kontenery a dziedziczenie (607)
19.3.4. Liczby całkowite jako parametry szablonów (608)
19.3.5. Dedukcja argumentów szablonu (610)
19.3.6. Uogólnianie wektora (610)

19.4. Sprawdzanie zakresu i wyjątki (613)

19.4.1. Dygresja - uwagi projektowe (614)
19.4.2. Wyznanie na temat makr (615)

19.5. Zasoby i wyjątki (617)

19.5.1. Potencjalne problemy z zarządzaniem zasobami (617)
19.5.2. Zajmowanie zasobów jest inicjacją (619)
19.5.3. Gwarancje (620)
19.5.4. Obiekt auto_ptr (621)
19.5.5. Technika RAII dla wektora (622)

Rozdział 20. Kontenery i iteratory (629)

20.1. Przechowywanie i przetwarzanie danych (630)

20.1.1. Praca na danych (630)
20.1.2. Uogólnianie kodu (631)

20.2. Ideały twórcy biblioteki STL (634)
20.3. Sekwencje i iteratory (637)

20.3.1. Powrót do przykładu (639)

20.4. Listy powiązane (641)

20.4.1. Operacje list (642)
20.4.2. Iteracja (643)

20.5. Jeszcze raz uogólnianie wektora (645)
20.6. Przykład - prosty edytor tekstu (647)

20.6.1. Wiersze (649)
20.6.2. Iteracja (650)

20.7. Typy vector, list oraz string (653)

20.7.1. Funkcje insert() i erase() (654)

20.8. Dostosowanie wektora do biblioteki STL (656)
20.9. Dostosowywanie wbudowanych tablic do STL (658)
20.10. Przegląd kontenerów (660)

20.10.1. Kategorie iteratorów (662)

Rozdział 21. Algorytmy i słowniki (667)

21.1. Algorytmy biblioteki standardowej (668)
21.2. Najprostszy algorytm - find() (669)

21.2.1. Kilka przykładów z programowania ogólnego (670)

21.3. Ogólny algorytm wyszukiwania - find_if() (671)
21.4. Obiekty funkcyjne (673)

21.4.1. Abstrakcyjne spojrzenie na obiekty funkcyjne (674)
21.4.2. Predykaty składowych klas (675)

21.5. Algorytmy numeryczne (676)

21.5.1. Akumulacja (677)
21.5.2. Uogólnianie funkcji accumulate() (678)
21.5.3. Iloczyn skalarny (679)
21.5.4. Uogólnianie funkcji inner_product() (681)

21.6. Kontenery asocjacyjne (681)

21.6.1. Słowniki (682)
21.6.2. Opis ogólny kontenera map (684)
21.6.3. Jeszcze jeden przykład zastosowania słownika (687)
21.6.4. Kontener unordered_map (689)
21.6.5. Zbiory (691)

21.7. Kopiowanie (693)

21.7.1. Funkcja copy() (693)
21.7.2. Iteratory strumieni (694)
21.7.3. Utrzymywanie porządku przy użyciu kontenera set (696)
21.7.4. Funkcja copy_if() (696)

21.8. Sortowanie i wyszukiwanie (697)

Część IV: Poszerzanie horyzontów (703)
Rozdział 22. Ideały i historia (705)

22.1. Historia, ideały i profesjonalizm (706)

22.1.1. Cele i filozofie języków programowania (706)
22.1.2. Ideały programistyczne (708)
22.1.3. Style i paradygmaty (714)

22.2. Krótka historia języków programowania (717)

22.2.1. Pierwsze języki (718)
22.2.2. Korzenie nowoczesnych języków programowania (719)
22.2.3. Rodzina Algol (724)
22.2.4. Simula (731)
22.2.5. C (733)
22.2.6. C++ (736)
22.2.7. Dziś (738)
22.2.8. Źródła informacji (740)

Rozdział 23. Przetwarzanie tekstu (745)

23.1. Tekst (746)
23.2. Łańcuchy (746)
23.3. Strumienie wejścia i wyjścia (750)
23.4. Słowniki (750)

23.4.1. Szczegóły implementacyjne (755)

23.5. Problem (757)
23.6. Wyrażenia regularne (759)
23.7. Wyszukiwanie przy użyciu wyrażeń regularnych (761)
23.8. Składnia wyrażeń regularnych (764)

23.8.1. Znaki i znaki specjalne (764)
23.8.2. Rodzaje znaków (765)
23.8.3. Powtórzenia (766)
23.8.4. Grupowanie (767)
23.8.5. Alternatywa (767)
23.8.6. Zbiory i przedziały znaków (768)
23.8.7. Błędy w wyrażeniach regularnych (769)

23.9. Dopasowywanie przy użyciu wyrażeń regularnych (770)
23.10. Źródła (775)

Rozdział 24. Działania na liczbach (779)

24.1. Wprowadzenie (780)
24.2. Rozmiar, precyzja i przekroczenie zakresu (780)

24.2.1. Ograniczenia typów liczbowych (783)

24.3. Tablice (784)
24.4. Tablice wielowymiarowe w stylu języka C (785)
24.5. Biblioteka Matrix (786)

24.5.1. Wymiary i dostęp (787)
24.5.2. Macierze jednowymiarowe (789)
24.5.3. Macierze dwuwymiarowe (792)
24.5.4. Wejście i wyjście macierzy (794)
24.5.5. Macierze trójwymiarowe (795)

24.6. Przykład - rozwiązywanie równań liniowych (796)

24.6.1. Klasyczna eliminacja Gaussa (797)
24.6.2. Wybór elementu centralnego (798)
24.6.3. Testowanie (799)

24.7. Liczby losowe (800)
24.8. Standardowe funkcje matematyczne (802)
24.9. Liczby zespolone (803)
24.10. Źródła (804)

Rozdział 25. Programowanie systemów wbudowanych (809)

25.1. Systemy wbudowane (810)
25.2. Podstawy (813)

25.2.1. Przewidywalność (815)
25.2.2. Ideały (815)
25.2.3. Życie z awarią (816)

25.3. Zarządzanie pamięcią (818)

25.3.1. Problemy z pamięcią wolną (819)
25.3.2. Alternatywy dla ogólnej pamięci wolnej (822)
25.3.3. Przykład zastosowania puli (823)
25.3.4. Przykład użycia stosu (824)

25.4. Adresy, wskaźniki i tablice (825)

25.4.1. Niekontrolowane konwersje (825)
25.4.2. Problem - źle działające interfejsy (826)
25.4.3. Rozwiązanie - klasa interfejsu (829)
25.4.4. Dziedziczenie a kontenery (832)

25.5. Bity, bajty i słowa (834)

25.5.1. Bity i operacje na bitach (835)
25.5.2. Klasa bitset (839)
25.5.3. Liczby ze znakiem i bez znaku (840)
25.5.4. Manipulowanie bitami (844)
25.5.5. Pola bitowe (846)
25.5.6. Przykład - proste szyfrowanie (847)

25.6. Standardy pisania kodu (851)

25.6.1. Jaki powinien być standard kodowania (852)
25.6.2. Przykładowe zasady (854)
25.6.3. Prawdziwe standardy kodowania (859)

Rozdział 26. Testowanie (865)

26.1. Czego chcemy (866)

26.1.1. Zastrzeżenie (867)

26.2. Dowody (867)
26.3. Testowanie (867)

26.3.1. Testowanie regresyjne (868)
26.3.2. Testowanie jednostkowe (869)
26.3.3. Algorytmy i nie-algorytmy (875)
26.3.4. Testy systemowe (882)
26.3.5. Testowanie klas (886)
26.3.6. Znajdowanie założeń, które się nie potwierdzają (889)

26.4. Projektowanie pod kątem testowania (890)
26.5. Debugowanie (891)
26.6. Wydajność (891)

26.6.1. Kontrolowanie czasu (893)

26.7. Źródła (895)

Rozdział 27. Język C (899)

27.1. C i C++ to rodzeństwo (900)

27.1.1. Zgodność języków C i C++ (901)
27.1.2. Co jest w języku C++, czego nie ma w C (903)
27.1.3. Biblioteka standardowa języka C (904)

27.2. Funkcje (905)

27.2.1. Brak możliwości przeciążania nazw funkcji (906)
27.2.2. Sprawdzanie typów argumentów funkcji (906)
27.2.3. Definicje funkcji (907)
27.2.4. Wywoływanie C z poziomu C++ i C++ z poziomu C (909)
27.2.5. Wskaźniki na funkcje (911)

27.3. Mniej ważne różnice między językami (912)

27.3.1. Przestrzeń znaczników struktur (912)
27.3.2. Słowa kluczowe (913)
27.3.3. Definicje (914)
27.3.4. Rzutowanie w stylu języka C (915)
27.3.5. Konwersja typu void* (916)
27.3.6. Typ enum (917)
27.3.7. Przestrzenie nazw (917)

27.4. Pamięć wolna (918)
27.5. Łańcuchy w stylu języka C (919)

27.5.1. Łańcuchy w stylu języka C i const (922)
27.5.2. Operacje na bajtach (922)
27.5.3. Przykład - funkcja strcpy() (923)
27.5.4. Kwestia stylu (923)

27.6. Wejście i wyjście - nagłówek stdio (924)

27.6.1. Wyjście (924)
27.6.2. Wejście (925)
27.6.3. Pliki (927)

27.7. Stałe i makra (927)
27.8. Makra (928)

27.8.1. Makra podobne do funkcji (929)
27.8.2. Makra składniowe (930)
27.8.3. Kompilacja warunkowa (931)

27.9. Przykład - kontenery intruzyjne (932)

Dodatki (941)
Dodatek A: Zestawienie własności języka (943)

A.1. Opis ogólny (944)
A.2. Literały (946)
A.3. Identyfikatory (950)
A.4. Zakres, pamięć oraz czas trwania (950)
A.5. Wyrażenia (953)
A.6. Instrukcje (962)
A.7. Deklaracje (964)
A.8. Typy wbudowane (965)
A.9. Funkcje (968)
A.10. Typy zdefiniowane przez użytkownika (971)
A.11. Wyliczenia (972)
A.12. Klasy (972)
A.13. Szablony (983)
A.14. Wyjątki (986)
A.15. Przestrzenie nazw (988)
A.16. Aliasy (988)
A.17. Dyrektywy preprocesora (989)

Dodatek B: Biblioteka standardowa (991)

B.1. Przegląd (992)
B.2. Obsługa błędów (995)
B.3. Iteratory (997)
B.4. Kontenery (1001)
B.5. Algorytmy (1008)
B.6. Biblioteka STL (1016)
B.7. Strumienie wejścia i wyjścia (1018)
B.8. Przetwarzanie łańcuchów (1024)
B.9. Obliczenia (1028)
B.10. Funkcje biblioteki standardowej C (1032)
B.11. Inne biblioteki (1040)

Dodatek C: Podstawy środowiska Visual Studio (1043)

C.1. Uruchamianie programu (1044)
C.2. Instalowanie środowiska Visual Studio (1044)
C.3. Tworzenie i uruchamianie programu (1044)
C.4. Później (1046)

Dodatek D: Instalowanie biblioteki FLTK (1047)

D.1. Wprowadzenie (1048)
D.2. Pobieranie biblioteki FLTK z internetu (1048)
D.3. Instalowanie biblioteki FLTK (1048)
D.4. Korzystanie z biblioteki FLTK w Visual Studio (1049)
D.5. Sprawdzanie, czy wszystko działa (1050)

Dodatek E: Implementacja GUI (1051)

E.1. Implementacja wywołań zwrotnych (1052)
E.2. Implementacja klasy Widget (1053)
E.3. Implementacja klasy Window (1054)
E.4. Klasa Vector_ref (1055)
E.5. Przykład - widgety (1056)

Słowniczek (1059)
Bibliografia (1065)
Skorowidz (1069)
Zdjęcia (1105)

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

Liczba ocen: 8

Średnia ocena
czytelników

Oceń książkę

Ocena : 6

2010-05-18

bez podpisu

Dla początkujących: genialna, brać w ciemno Dla zaawansowanych: zastanowić się trzy razy. Autor sam pisze, że dla wtajemniczonych przeznaczone są inne publikacje. Świetną rzeczą jest masa ćwiczeń po każdym rozdziale.

Ocena : 6

2010-06-02

Marcin Pastusiak, Informatyk

Znakomita dla początkujących jak i dla bardziej zaawansowanych. Poprzez przykłady i ćwiczenia każdy się nauczy tego najpopularniejszego języka.

Ocena : 6

2010-03-29

bez podpisu

Bez wahania mogę powiedzieć ze jest to książka najlepsza na polskim rynku. Czytałem wcześniej książkę w oryginale i bardzo mi się podobała. Ma kilka drobnych niedociągnięć w tłumaczeniu ale nie przeszkadza to w rozumieniu. Książka jest absolutnym podręcznikiem od lamera (czyt. początkującego) do bardzo zaawansowanego!!! Poczynając na hello world, poprzez algorytmy biblioteki i kończąc na okienkowych aplikacjach z wykorzystaniem GUI!!! Kilka lat temu kopiłem c++ dla wszystkich, która uważam za świetna i stwierdzam że kiażka Briana jest 10x lepsza!!! Jeśli nie masz pojęcia o c++ a chcesz go się nauczyć do poziomu wysoce zaawansowanego poprzez przerobienie jednej pozycji to GORĄCO POLECAM! BRAĆ W CIEMNO!

Ocena : 6

2013-04-20

Marek Wlizło, programista C++

Jeśli ktoś planuje rozpocząć przygodę z programowanie to polecam sięgnąć do tej pozycji dopiero po przeczytaniu Symfonii i Pasji C++. Książka ta pozwala zgłębić i utrwalić wiedzę z zakresu programowania.

Ocena : 6

2010-10-28

Dariusz Donimirski, programista

Czytając recenzję BrunaWątpliwego można by odnieść wrażenie, że autor nonszalancko podszedł do prezentowanego tematu. Najwyraźniej Bruno nie doczytał, że książka jest adresowana do ludzi stawiających pierwsze kroki i cytując autora, jeżeli jesteś ekspertem tak książka nie jest dla Ciebie. Zapominając o Brunie i wracając do książki. Jest ona napisana niesłychanie przystępnym językiem, wyjaśnia każde omawiane pojęcie do "szpiku kości". Przybliża wiele technik popełniania błędów i patrzenia na programowanie profesjonalnie. Czytają tą książkę czuje się, że autor wie o czym pisze. Nie są w niej prezentowane zawiłości maksymalnie zaawansowanych technik, ale solidna wiedza na temat programowania i języka C++. W tematach, które autor uważa za zaawansowane odsyła czytelnika do innych perełek w tej dziedzinie. Tylko czytelnik zaawansowany w tym temacie jest wstanie docenić tą pozycję. Czyta się ją wtedy jak powieść. Po każdym rozdziale są zadania i pytania do rozważenia, dla bardziej wnikliwych. Moim zdaniem jest to najlepszy podręcznik dla zaczynających zabawę z programowaniem w C++. Rewelacyjnie jest przeczytać solidny opis rdzenia języka i sposobów jego wykorzystania napisany w prosty sposób, ale nie za prosty.

Ocena : 6

2012-08-06

bez podpisu

Ocena : 5

2010-10-11

bez podpisu, elektronik

Świetna pozycja dla początkujących, jak również, dla średnio zaawansowanych. Podanych jest wiele ciekawych aspektów programowania, momentami rzuca na głęboką wodę, ale jest dużo lepszą pozycją od symfoni C++, chociaż posiadam też wszystkie grębosza :).

Ocena : 2

2010-04-09

BrunoWątpliwy

Rzucając okiem na prezentowaną treść mogę śmiało orzec, iż publikacja pod względem treści nie wyróżnia się imponująco. Poruszonych pozostaje wiele kwestii, jednak ich poziom zagłębienie jest po prostu zbyt płytki, aby można było ze zdobytymi wieściami robić cuda. Książki, które poruszają właściwie wszystko na jednym ogniu nie przekazują najlepszych informacji, a jedynie stanowią wycieczkę turystyczną dla nieobeznanych. Jeżeli czytelnik jest programistą, którego kariera poczyna i zarazem kończy się na konsoli, to owa książka zyska w nim uznanie. W przeciwnym razie, książka okaże się kolejnym źródłem płytkich wieści. W końcu cóż to jest narysować kilka prostych na ekranie i osadzić dwa przyciski na formie okna. W pozycji szczególnie nie podoba mi się wygórowana cena, która za pewnie wynika tylko i wyłącznie z nazwiska autora.