c++. potęga języka. od przykładu do przykładu helion.pdf

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++.

Practical Programming by Example

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

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

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

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.

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika: