Programowanie. Teoria i praktyka z wykorzystaniem C++ (ebook)(audiobook)(audiobook)
- Autor:
- Bjarne Stroustrup
Niedostępna
- Wydawnictwo:
- Helion
- Ocena:
- 5.3/6 Opinie: 12
- Stron:
- 1112
- Druk:
- oprawa twarda
Opis książki
Czytaj fragment
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++!
Szczegóły książki
- 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
Spis treści
- Słowo do studentów (21)
- Słowo do nauczycieli (22)
- Pomoc (23)
- Podziękowania (23)
- 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)
- 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)
- 2.1. Programy (64)
- 2.2. Klasyczny pierwszy program (64)
- 2.3. Kompilacja (67)
- 2.4. Łączenie (69)
- 2.5. Środowiska programistyczne (70)
- 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)
- 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)
- 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)
- 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)
- 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)
- 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)
- 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)
- 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)
- 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)
- 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)
- 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)
- 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)
- 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)
- 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)
- 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)
- 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)
- 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)
- 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)
- 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)
- 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)
- 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)
- 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)
- 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)
- 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)
- 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)
- 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)
- 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)
- C.1. Uruchamianie programu (1044)
- C.2. Instalowanie środowiska Visual Studio (1044)
- C.3. Tworzenie i uruchamianie programu (1044)
- C.4. Później (1046)
- 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)
- 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)
Wstęp (19)
Uwagi do czytelnika (25)
Rozdział 1. Komputery, ludzie i programowanie (39)
Część I: Podstawy (61)
Rozdział 2. Witaj, świecie! (63)
Rozdział 3. Obiekty, typy i wartości (77)
Rozdział 4. Wykonywanie obliczeń (103)
Rozdział 5. Błędy (139)
Rozdział 6. Pisanie programu (175)
Rozdział 7. Kończenie programu (217)
Rozdział 8. Szczegóły techniczne - funkcje itp. (247)
Rozdział 9. Szczegóły techniczne - klasy itp. (287)
Część II: Wejście i wyjście (319)
Rozdział 10. Strumienie wejścia i wyjścia (321)
Rozdział 11. Indywidualizacja operacji wejścia i wyjścia (353)
Rozdział 12. Model graficzny (381)
Rozdział 13. Klasy graficzne (407)
Rozdział 14. Projektowanie klas graficznych (443)
Rozdział 15. Graficzne przedstawienie funkcji i danych (471)
Rozdział 16. Graficzne interfejsy użytkownika (497)
Część III: Dane i algorytmy (523)
Rozdział 17. Wektory i pamięć wolna (525)
Rozdział 18. Wektory i tablice (563)
Rozdział 19. Wektory, szablony i wyjątki (593)
Rozdział 20. Kontenery i iteratory (629)
Rozdział 21. Algorytmy i słowniki (667)
Część IV: Poszerzanie horyzontów (703)
Rozdział 22. Ideały i historia (705)
Rozdział 23. Przetwarzanie tekstu (745)
Rozdział 24. Działania na liczbach (779)
Rozdział 25. Programowanie systemów wbudowanych (809)
Rozdział 26. Testowanie (865)
Rozdział 27. Język C (899)
Dodatki (941)
Dodatek A: Zestawienie własności języka (943)
Dodatek B: Biblioteka standardowa (991)
Dodatek C: Podstawy środowiska Visual Studio (1043)
Dodatek D: Instalowanie biblioteki FLTK (1047)
Dodatek E: Implementacja GUI (1051)
Słowniczek (1059)
Bibliografia (1065)
Skorowidz (1069)
Zdjęcia (1105)
Oceny i opinie klientów (12)
Dodaj opinię6 oceniona przez: 2010-05-18
6 oceniona przez: 2012-08-06
6 oceniona przez: 2010-03-29
6 oceniona przez: Michał, Programista, uzależniony od C++ :) 2016-10-03
6 oceniona przez: 2013-09-13
6 oceniona przez: Marek Wlizło, programista C++ 2013-04-20
6 oceniona przez: Marcin Pastusiak, Informatyk 2010-06-02
6 oceniona przez: Dariusz Donimirski, programista 2010-10-28
5 oceniona przez: 2013-09-10
5 oceniona przez: elektronik 2010-10-11
3 oceniona przez: 2013-06-08
2 oceniona przez: BrunoWątpliwy, 2010-04-09
więcej opinii