C_Potega_jezyka_Od_przykladu_do_przykladu_cpojez.pdf

(698 KB) Pobierz
IDZ DO
PRZYK£ADOWY ROZDZIA£
SPIS TRE CI
KATALOG KSI¥¯EK
KATALOG ONLINE
ZAMÓW DRUKOWANY KATALOG
C++. Potêga jêzyka.
Od przyk³adu do przyk³adu
Autorzy: Andrew Koenig, Barbara E. Moo
T³umaczenie: Przemys³aw Szeremiota
ISBN: 83-7361-374-9
Tytu³ orygina³u:
Accelerated C++.
Practical Programming by Example
Format: B5, stron: 422
Przyk³ady na ftp: 122 kB
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
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++. Jako programista z trzydziestoletnim sta¿em (piêtna cie lat po wiêconych C++)
opublikowa³ ponad 150 artyku³ów i wyg³osi³ mnóstwo odczytów o tym jêzyku.
Barbara E. Moo
jest konsultantk¹ z dwudziestoletnim do wiadczeniem
programistycznym. Pracuj¹c przez 15 lat dla AT&T wspó³tworzy³a jeden z pierwszych
komercyjnych produktów tworzonych w jêzyku C++, zarz¹dza³a projektem pierwszego
kompilatora C++ firmy AT&T i kierowa³a rozwojem uznanego systemu AT&T WorldNet
Internet Service. Jest wspó³autork¹ ksi¹¿ki „Ruminations on C++”. Wyk³ada na ca³ym
wiecie.
TWÓJ KOSZYK
DODAJ DO KOSZYKA
CENNIK I INFORMACJE
ZAMÓW INFORMACJE
O NOWO CIACH
ZAMÓW CENNIK
CZYTELNIA
FRAGMENTY KSI¥¯EK ONLINE
Wydawnictwo Helion
ul. Chopina 6
44-100 Gliwice
tel. (32)230-98-63
e-mail: helion@helion.pl
Spis treści
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
Rozdział 1. Operacje na ciągach ........................................................................ 25
1.1. Wejście programu ......................................................................................................25
1.2. Ozdabianie powitania.................................................................................................28
1.3. Podsumowanie ...........................................................................................................32
Rozdział 2. Pętle i liczniki.................................................................................. 37
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
Rozdział 3. Przetwarzanie porcji danych .............................................................. 61
3.1. Obliczanie średniej ocen z egzaminów ......................................................................61
3.2. Mediana zamiast średniej ...........................................................................................68
3.3. Podsumowanie ...........................................................................................................77
Rozdział 4. Organizacja programów i danych ...................................................... 81
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
6
C++. Potęga języka. Od przykładu do przykładu
Rozdział 5. Kontenery sekwencyjne i analiza ciągów tekstowych....................... 109
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
Rozdział 6. Korzystanie z algorytmów biblioteki standardowej........................... 141
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
Rozdział 7. Stosowanie kontenerów asocjacyjnych ........................................... 169
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
Rozdział 8. Pisanie funkcji uogólnionych.............................................................. 189
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 dozwiększeniaelastycznościprogramów................................204
8.5. Podsumowanie .........................................................................................................205
Rozdział 9. Definiowanie własnych typów ......................................................... 209
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
Rozdział 10. Zarządzanie pamięcią i niskopoziomowymi strukturami danych........ 227
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
Rozdział 11. Definiowanie abstrakcyjnych typów danych ........................................ 249
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
Spis treści
7
Rozdział 12. Obiekty typów definiowanych przez użytkownika jako wartości........ 279
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
Rozdział 13. Dziedziczenie i wiązanie dynamiczne............................................... 299
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
Rozdział 14. Automatyczne (prawie) zarządzanie pamięcią.................................. 329
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
Rozdział 15. Obrazki znakowe — podejście drugie.............................................. 347
15.1. Projekt ....................................................................................................................348
15.2. Implementacja ........................................................................................................357
15.3. Podsumowanie .......................................................................................................368
Rozdział 16. Co dalej?....................................................................................... 371
16.1. Korzystaj z posiadanych narzędzi ..........................................................................371
16.2. Pogłębiaj wiedzę ....................................................................................................373
Dodatek A Tajniki języka................................................................................. 375
A.1. Deklaracje................................................................................................................375
A.2. Typy.........................................................................................................................380
A.3. Wyra enia................................................................................................................388
A.4. Instrukcje .................................................................................................................391
Dodatek B Opis biblioteki ............................................................................... 395
B.1. Wejście i wyjście .....................................................................................................396
B.2. Kontenery i iteratory................................................................................................399
B.3. Algorytmy................................................................................................................411
Skorowidz......................................................................................417
Rozdział 6.
Korzystanie z algorytmów
biblioteki standardowej
W rozdziale 5. widzieliśmy, e wiele operacji wykonywanych na kontenerach da się
zastosować do więcej ni jednego typu kontenera. Przykładowo, typy
XGEVQT
,
UVTKPI
i
NKUV
pozwalają na realizację operacji wstawiania elementów za pośrednictwem me-
tody
KPUGTV
i usuwania elementów metodą
GTCUG
. Operacje te realizowane są za po-
średnictwem identycznego we wszystkich trzech przypadkach interfejsu. Dzięki temu
wiele z operacji charakterystycznych dla kontenerów da się wykonać równie wobec
obiektów typu
UVTKPI
.
Ka dy kontener — równie klasa
UVTKPI
— udostępnia skojarzone z danym typem kon-
tenera klasy iteratorów, za pośrednictwem których mo na wybierać elementy z konte-
nera. Tu znów biblioteka standardowa troszczy się o to, aby ka dy z udostępnianych
iteratorów pozwalała na realizację pewnych operacji za pośrednictwem wspólnego dla
wszystkich iteratorów interfejsu. Dla przykładu, operator
daje się zastosować wobec
iteratora dowolnego typu i zawsze oznacza przesunięcie iteratora do następnego elementu
kontenera; operator

słu y z kolei do odwoływania się do elementu skojarzonego z ite-
ratorem, niezale nie od typu tego ostatniego.
W bie ącym rozdziale zobaczymy, w jaki sposób biblioteka standardowa wykorzystuje
koncepcję wspólnego interfejsu w udostępnianiu zbioru tak zwanych standardowych
algorytmów. Korzystając z tych algorytmów, unikamy pisania i przepisywania wcią
tego samego kodu dla ró nych struktur danych. Co wa niejsze, mo emy dzięki nim
pisać programy prostsze i mniejsze ni gdybyśmy wszystkie algorytmy implementowali
sami — niekiedy ró nica rozmiarów i prostoty oprogramowania w wyniku zastosowania
algorytmów standardowych mo e być ogromna.
Algorytmy, podobnie jak iteratory i kontenery, równie wykorzystują konwencję spój-
nego interfejsu. Spójność ta pozwala nam ograniczyć naukę do kilku algorytmów i na
zastosowanie zdobytych doświadczeń w pracy z pozostałymi algorytmami. W tym roz-
dziale do rozwiązywania problemów związanych z przetwarzaniem ciągów typu
UVTKPI
i ocen studentów wykorzystamy kilka standardowych algorytmów. Przy okazji nauczy-
my się korzystać z większości kluczowych koncepcji algorytmów biblioteki standardowej.

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika:

Zgłoś jeśli naruszono regulamin