Nie ucz się C++ -- naucz się programować w C++
- C++ od najprzydatniejszych elementów, a nie od elementów najprostszych
- Rzeczywiste zadania i ich rozwiązania
- Opis C++ i biblioteki standardowej
- Książka sprawdzona w praktyce na Uniwersytecie Stanford
Książka ta ma pomóc Czytelnikowi w szybkim nauczeniu się języka C++ poprzez pisanie w nim przydatnych programów. Ta strategia wydaje się oczywista, jednak jest odmienna od powszechnie przyjętej metodologii nauczania. Autorzy nie będą uczyć Cię języka C, choć wielu uważa, że jest to niezbędne. W prezentowanych przykładach od razu wykorzystane zostaną wysokopoziomowe struktury, a prezentacja sposobu ich zastosowania będzie często wyprzedzać omówienie ich fundamentów. Dzięki takiemu podejściu zaczniesz szybko pisać programy wykorzystujące idiomy C++.
Zastosowany w książce schemat autorzy wypróbowali podczas kursów prowadzonych na Uniwersytecie Stanforda, na których studenci uczą się pisać programy już na pierwszych zajęciach.
Poznaj:- Podstawowe cechy C++
- Operacje na ciągach
- Pętle i liczniki
- Przetwarzanie danych "porcja po porcji"
- Organizację programów i danych
- Kontenery sekwencyjne i analiza ciągów tekstowych
- Algorytmy biblioteki standardowej
- Kontenery asocjacyjne
- Funkcje uogólnione i definiowanie własnych typów
- Zarządzanie pamięcią i niskopoziomowymi strukturami danych
- Półautomatyczne zarządzanie pamięcią
- Programowanie zorientowane obiektowo
O autorach:
Andrew Koenig jest członkiem działu badającego systemy oprogramowania w Shannon Laboratory firmy AT&T oraz redaktorem projektu komitetów standaryzacyjnych języka C++. [więcej...\
Barbara Moo jest konsultantką z dwudziestoletnim doświadczeniem programistycznym, zarządzała projektem pierwszego kompilatora C++. [więcej...\
Przedmowa (9)Wstęp (15)
- Zaczynamy (15)
- W.1. Komentarze (16)
- W.2. Dyrektywa #include (16)
- W.3. Funkcja main (16)
- W.4. Nawiasy klamrowe (17)
- W.5. Wykorzystanie biblioteki standardowej do realizacji operacji wyjścia (17)
- W.6. Instrukcja return (18)
- W.7. Nieco głębsza analiza (19)
- W.8. Podsumowanie (21)
- 1.1. Wejście programu (25)
- 1.2. Ozdabianie powitania (28)
- 1.3. Podsumowanie (32)
- 2.1. Zadanie (37)
- 2.2. Ogólna struktura programu (38)
- 2.3. Wypisywanie nieznanej z góry liczby wierszy (38)
- 2.4. Wypisywanie wierszy (43)
- 2.5. Połączenie fragmentów programu (48)
- 2.6. Zliczanie (52)
- 2.7. Podsumowanie (54)
- 3.1. Obliczanie średniej ocen z egzaminów (61)
- 3.2. Mediana zamiast średniej (68)
- 3.3. Podsumowanie (77)
- 4.1. Organizacja przetwarzania (82)
- 4.2. Organizacja danych (93)
- 4.3. Połączenie fragmentów programu (98)
- 4.4. Podział programu wyznaczającego oceny semestralne (101)
- 4.5. Ostateczna wersja programu (103)
- 4.6. Podsumowanie (105)
- 5.1. Dzielenie studentów na grupy (109)
- 5.2. Iteratory (114)
- 5.3. Wykorzystanie iteratorów w miejsce indeksów (118)
- 5.4. Ulepszanie struktury danych pod kątem większej wydajności (120)
- 5.5. Kontener typu list (121)
- 5.6. Wracamy do ciągów typu string (124)
- 5.7. Testowanie funkcji split (127)
- 5.8. Kolekcjonowanie zawartości ciągu typu string (129)
- 5.9. Podsumowanie (134)
- 6.1. Analiza ciągów znakowych (142)
- 6.2. Porównanie metod wyznaczania ocen (151)
- 6.3. Klasyfikacja studentów - podejście drugie (159)
- 6.4. Algorytmy, kontenery, iteratory (163)
- 6.5. Podsumowanie (164)
- 7.1. Kontenery obsługujące szybkie wyszukiwanie (169)
- 7.2. Zliczanie wyrazów (171)
- 7.3. Generowanie tabeli odsyłaczy (173)
- 7.4. Generowanie prostych zdań (176)
- 7.5. Słowo o wydajności (184)
- 7.6. Podsumowanie (185)
- 8.1. Czym jest funkcja uogólniona? (189)
- 8.2. Niezależność od struktur danych (194)
- 8.3. Iteratory wejściowe i wyjściowe (202)
- 8.4. Wykorzystanie iteratorów do zwiększenia elastyczności programów (204)
- 8.5. Podsumowanie (205)
- 9.1. Rewizja typu Student_info (209)
- 9.2. Typy definiowane przez użytkownika (210)
- 9.3. Ochrona składowych (214)
- 9.4. Klasa Student_info (219)
- 9.5. Konstruktory (219)
- 9.6. Stosowanie klasy Student_info (222)
- 9.7. Podsumowanie (223)
- 10.1. Wskaźniki i tablice (228)
- 10.2. Literały łańcuchowe - powtórka (235)
- 10.4. Argumenty funkcji main (238)
- 10.5. Odczyt i zapis plików (239)
- 10.6. Trzy tryby zarządzania pamięcią (242)
- 10.7. Podsumowanie (245)
- 11.1. Klasa Vec (249)
- 11.2. Implementacja klasy Vec (250)
- 11.3. Kontrola operacji kopiowania (258)
- 11.4. Pamięć dynamiczna w klasie Vec (267)
- 11.5. Elastyczne zarządzanie pamięcią (269)
- 11.6. Podsumowanie (275)
- 12.1. Prosta klasa ciągów (280)
- 12.2. Konwersje automatyczne (281)
- 12.3. Operacje wykonywane na klasie Str (283)
- 12.4. Ryzykowne konwersje (290)
- 12.5. Operatory konwersji (292)
- 12.6. Konwersje a zarządzanie pamięcią (293)
- 12.7. Podsumowanie (295)
- 13.1. Dziedziczenie (299)
- 13.2. Polimorfizm i funkcje wirtualne (305)
- 13.3. Rozwiązanie zadania z użyciem dziedziczenia (310)
- 13.4. Prosta klasa manipulatora (316)
- 13.5. Stosowanie klasy manipulatora (321)
- 13.6. Niuanse (323)
- 13.7. Podsumowanie (324)
- 14.1. Manipulatory kopiujące obiekty docelowe (330)
- 14.2. Manipulatory zliczające odwołania (337)
- 14.3. Manipulatory z opcją współużytkowania danych (340)
- 14.4. Ulepszanie manipulatorów (342)
- 14.5. Podsumowanie (346)
- 15.1. Projekt (348)
- 15.2. Implementacja (357)
- 15.3. Podsumowanie (368)
- 16.1. Korzystaj z posiadanych narzędzi (371)
- 16.2. Pogłębiaj wiedzę (373)
- A.1. Deklaracje (375)
- A.2. Typy (380)
- A.3. Wyrażenia (388)
- A.4. Instrukcje (391)
- B.1. Wejście i wyjście (396)
- B.2. Kontenery i iteratory (399)
- B.3. Algorytmy (411)