C++ Potega jezyka Od przykladu do przykladu.pdf

(711 KB) Pobierz
C:\Andrzej\PDF\ABC nagrywania p³yt CD\1 strona.cdr
IDZ DO
PRZYK£ADOW Y ROZDZIA£
C++. Potêga jêzyka.
SPIS TRECI
Od przyk³adu do przyk³adu
KATALOG KSI¥¯EK
Autorzy: Andrew Koenig, Barbara E. Moo
T³umaczenie: Przemys³aw Szeremiota
ISBN: 83-7361-374-9
Tytu³ orygina³ u: Accelerated C++.
Format: B5, stron: 422
Przyk³ady na ftp: 122 kB
KATALOG ONLINE
ZAMÓW DRUKOWANY KATALOG
TWÓJ KOSZYK
DODAJ DO KOSZYKA
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
podejciu 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êtnacie lat powiê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 dowiadczeniem
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.
CENNIK I INFORMACJE
ZAMÓW INFORMACJE
O NOWOCIACH
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
24888151.001.png 24888151.002.png 24888151.003.png
Spis treci
Przedmowa........................................................................................9
Wstp .............................................................................................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 cigach ........................................................................25
1.1. Wej%cie programu......................................................................................................25
1.2. Ozdabianie powitania.................................................................................................28
1.3. Podsumowanie...........................................................................................................32
Rozdział 2. Ptle 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++. Potga jzyka. Od przykładu do przykładu
Rozdział 5. Kontenery sekwencyjne i analiza cigó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 do zwi*kszenia elastyczno%ci programó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. Zarzdzanie pamici i niskopoziomowymi strukturami danych........227
10.1. WskaBniki 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 treci
7
Rozdział 12. Obiekty typów definiowanych przez u0ytkownika jako warto1ci........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 wizanie 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) zarzdzanie pamici..................................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 — podej1cie 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 jzyka.................................................................................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. widzielimy, e wiele operacji wykonywanych na kontenerach da si
zastosowa do wicej ni jednego typu kontenera. Przykładowo, typy ,
i pozwalaj! na realizacj operacji wstawiania elementów za porednictwem me-
tody i usuwania elementów metod! . Operacje te realizowane s! za po-
rednictwem identycznego we wszystkich trzech przypadkach interfejsu. Dziki temu
wiele z operacji charakterystycznych dla kontenerów da si wykona równie wobec
obiektów typu .
Kady kontener — równie klasa — udostpnia skojarzone z danym typem kon-
tenera klasy iteratorów, za porednictwem których mona wybiera elementy z konte-
nera. Tu znów biblioteka standardowa troszczy si o to, aby kady z udostpnianych
iteratorów pozwalała na realizacj pewnych operacji za porednictwem wspólnego dla
wszystkich iteratorów interfejsu. Dla przykładu, operator daje si zastosowa wobec
iteratora dowolnego typu i zawsze oznacza przesunicie iteratora do nastpnego elementu
kontenera; operator słuy z kolei do odwoływania si do elementu skojarzonego z ite-
ratorem, niezalenie od typu tego ostatniego.
W bie!cym rozdziale zobaczymy, w jaki sposób biblioteka standardowa wykorzystuje
koncepcj wspólnego interfejsu w udostpnianiu 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 waniejsze, moemy dziki nim
pisa programy prostsze i mniejsze ni gdybymy wszystkie algorytmy implementowali
sami — niekiedy rónica rozmiarów i prostoty oprogramowania w wyniku zastosowania
algorytmów standardowych moe 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 dowiadcze/ w pracy z pozostałymi algorytmami. W tym roz-
dziale do rozwi!zywania problemów zwi!zanych z przetwarzaniem ci!gów typu
i ocen studentów wykorzystamy kilka standardowych algorytmów. Przy okazji nauczy-
my si korzysta z wikszoci kluczowych koncepcji algorytmów biblioteki standardowej.
 
Zgłoś jeśli naruszono regulamin