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++!
O autorze
1 Bjarne StroustrupDr Bjarne Stroustrup może mówić o sobie, że jest ojcem C++: zaprojektował go i jako pierwszy zaimplementował. Jest dyrektorem działu technologicznego banku Morgan Stanley w Nowym Jorku i profesorem wizytującym w Columbia University. Wcześniej pracował w Bell Labs, AT&T Labs oraz Texas A&M University. Otrzymał wiele wyróżnień, w tym przyznawaną przez National Academy of Engineering Nagrodę Charlesa Starka Drapera. Jest członkiem National Academy of Engineering, Institute of Electrical and Electronics Engineers (IEEE) oraz Association for Computing Machinery (ACM).
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
- Erraty / Zgłoś erratę
- Kategorie:
Programowanie » C++ - Programowanie
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