C++ Styl i technika zaawansowanego programowania.pdf

IDZ DO

PRZYK£ADOW Y ROZDZIA£

C++. Styl i technika

SPIS TRECI

zaawansowanego

KATALOG KSI¥¯EK

programowania

Autor: James O. Coplien

T³umaczenie: Jaromir Senczyk

ISBN: 83-7361-322-6

Tytu³ orygina³ u: Advanced C++

Programming Styles and Idioms

Format: B5, stron: 480

KATALOG ONLINE

ZAMÓW DRUKOWANY KATALOG

TWÓJ KOSZYK

DODAJ DO KOSZYKA

CENNIK I INFORMACJE

Zak³adaj¹c znajomoæ podstaw jêzyka C++ ksi¹¿ka ta umo¿liwia programistom

rozwiniêcie zaawansowanych umiejêtnoci programowania poprzez stosowanie styli

i idiomów jêzyka C++. Struktura ksi¹¿ki zorganizowana jest wokó³ abstrakcji

wspieranych przez jêzyk C++: abstrakcyjnych typów danych, kombinacji typów

w strukturach dziedziczenia, programowania obiektowego i dziedziczenia wielokrotnego.

W ksi¹¿ce przedstawione zostaj¹ tak¿e te idiomy, które nie znajduj¹ bezporedniego

wsparcia w jêzyku C++, takie jak wirtualne konstruktory, obiekty prototypów

i zaawansowane techniki odzyskiwania nieu¿ytków.

Ksi¹¿ka:

• Przedstawia zalety i potencjalne pu³apki zaawansowanych technik

programowania w jêzyku C++.

• Sposoby efektywnego ³¹czenia abstrakcji jêzyka C++ ilustruje szeregiem krótkich,

ale stanowi¹cych wystarczaj¹cy instrukta¿ przyk³adów.

• Dostarcza wielu praktycznych zasad wykorzystania jêzyka C++ do implementacji

rezultatów projektowania obiektowego.

• Omawia wszystkie w³aciwoci edycji 3.0 jêzyka C++, w tym zastosowanie

szablonów w celu wielokrotnego wykorzystania kodu.

• Przedstawia istotne aspekty rozwoju z³o¿onych systemów, w tym projektowanie

bibliotek, obs³ugê wyj¹tków i przetwarzanie rozproszone.

Ksi¹¿ka ta jest wa¿nym podrêcznikiem dla ka¿dego programisty aplikacji lub

programisty systemowego pos³uguj¹cego siê jêzykiem C++.

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

Rozdział 1. Wprowadzenie .................................................................................15

1.1. Ewolucja jzyka C++ .................................................................................................15

1.2. Idiomy jako sposób na złoono problemów ...........................................................16

1.3. Obiekty lat 90-tych.....................................................................................................18

1.4. Projektowanie i jzyk programowania.......................................................................19

Bibliografia........................................................................................................................20

Rozdział 2. Abstrakcyjne typy danych ................................................................21

2.1. Klasy...........................................................................................................................22

2.2. Inwersja obiektowa ....................................................................................................25

2.3. Konstruktory i destruktory .........................................................................................28

2.4. Funkcje rozwijane w miejscu wywołania ..................................................................32

2.5. Inicjacja statycznych danych składowych..................................................................34

2.6. Statyczne funkcje składowe .......................................................................................35

2.7. Zakresy i słowo kluczowe const.................................................................................36

2.8. Porz6dek inicjacji obiektów globalnych, stałych i składowych statycznych.............38

2.9. Słowo const i funkcje składowe.................................................................................39

2.10. Wska9niki funkcji składowych ................................................................................41

2.11. Konwencje programowania......................................................................................45

:wiczenia..........................................................................................................................46

Bibliografia........................................................................................................................47

Rozdział 3. Konkretne typy danych ....................................................................49

3.1. Ortodoksyjna posta kanoniczna klasy ......................................................................50

3.2. Zakresy i kontrola dostpu.........................................................................................56

3.3. Przeci6anie — zmiana semantyki funkcji i operatorów...........................................59

3.4. Konwersja typu ..........................................................................................................64

3.5. Zliczanie referencji i zmienne wykorzystuj6ce „magiczn6” pami .........................67

3.6. Operatory new i delete ...............................................................................................80

3.7. Separacja tworzenia instancji i jej inicjacji................................................................85

:wiczenia..........................................................................................................................88

Bibliografia........................................................................................................................90

Rozdział 4. Dziedziczenie...................................................................................91

4.1. Dziedziczenie pojedyncze..........................................................................................93

4.2. Zakresy deklaracji i kontrola dostpu ........................................................................99

4.3. Konstruktory i destruktory .......................................................................................109

4.4. Konwersje wska9ników klas....................................................................................112

C++. Styl i technika zaawansowanego programowania

4.5. Selektory typu ..........................................................................................................114

:wiczenia........................................................................................................................116

Bibliografia......................................................................................................................118

Rozdział 5. Programowanie obiektowe...............................................................119

5.1. Funkcje wirtualne.....................................................................................................121

5.2. Interakcje destruktorów i destruktory wirtualne ......................................................128

5.3. Funkcje wirtualne i zakresy......................................................................................129

5.4. Funkcje czysto wirtualne i abstrakcyjne klasy bazowe............................................131

5.5. Klasa kopertowa i klasa listu....................................................................................133

5.6. Funktory — funkcje jako obiekty ............................................................................161

5.7. Dziedziczenie wielokrotne.......................................................................................172

5.8. Kanoniczna posta dziedziczenia.............................................................................182

:wiczenia........................................................................................................................186

Przykład iteratora kolejki ................................................................................................187

Przykład klas prostej aplikacji bankowej..........................................................................188

Bibliografia......................................................................................................................190

Rozdział 6. Projektowanie obiektowe...............................................................191

6.1. Typy i klasy..............................................................................................................192

6.2. Czynnoci projektowania obiektowego ...................................................................196

6.3. Analiza obiektowa i analiza dziedziny.....................................................................199

6.4. Zwi6zki obiektów i klas ...........................................................................................202

6.5. Podtypy, dziedziczenie i przekazywanie..................................................................210

6.6. Praktyczne zasady tworzenia podtypów, stosowania dziedziczenia

i niezalenoci klas .......................................................................................................229

:wiczenia........................................................................................................................231

Bibliografia......................................................................................................................232

Rozdział 7. Ponowne u'ycie i obiekty...............................................................233

7.1. Gdy analogie przestaj6 działa .................................................................................235

7.2. Projektowanie z myl6 o ponownym uyciu............................................................237

7.3. Cztery mechanizmy ponownego uycia kodu..........................................................239

7.4. Typy parametryczne czyli szablony.........................................................................241

7.5. Ponowne uycie i dziedziczenie prywatne...............................................................249

7.6. Ponowne uycie pamici..........................................................................................252

7.7. Ponowne uycie interfejsu — warianty ...................................................................253

7.8. Ponowne uycie, dziedziczenie i przekazywanie.....................................................255

7.9. Ponowne uycie kodu 9ródłowego...........................................................................256

7.10. Ogólne uwagi na temat ponownego uycia............................................................259

:wiczenia........................................................................................................................260

Bibliografia......................................................................................................................261

Rozdział 8. Programowanie za pomoc) przykładów...........................................263

8.1. Przykład — przykłady pracowników.......................................................................266

8.2. Konstruktory ogólne — idiom zespołu przykładów ................................................271

8.3. Autonomiczne konstruktory ogólne.........................................................................273

8.4. Abstrakcyjne przykłady bazowe ..............................................................................275

8.5. Ku idiomowi szkieletu przykładu ............................................................................278

8.6. Uwagi na temat notacji.............................................................................................280

8.7. Przykłady i administracja kodem programu.............................................................282

:wiczenia........................................................................................................................283

Prosty parser wykorzystuj6cy przykłady.........................................................................284

Przykład wykorzystuj6cy szczeliny ................................................................................286

Bibliografia......................................................................................................................288

Spis treci

Rozdział 9. Emulacja j-zyków symbolicznych w C++.........................................289

9.1. Przyrostowy rozwój programów w jzyku C++ ......................................................291

9.2. Symboliczna posta kanoniczna...............................................................................293

9.3. Przykład — ogólna klasa kolekcji............................................................................304

9.4. Kod i idiomy obsługuj6ce mechanizm ładowania przyrostowego...........................308

9.5. Odzyskiwanie nieuytków .......................................................................................318

9.6. Hermetyzacja typów podstawowych........................................................................327

9.7. Wielometody i idiom symboliczny ..........................................................................328

:wiczenia........................................................................................................................332

Bibliografia......................................................................................................................333

Rozdział 10. Dynamiczne dziedziczenie wielokrotne............................................335

10.1. Przykład — system okienkowy..............................................................................336

10.2. Ograniczenia...........................................................................................................339

Rozdział 11. Zagadnienia systemowe.................................................................341

11.1. Statyczne projektowanie systemów .......................................................................342

11.2. Dynamiczne projektowanie systemów...................................................................350

Bibliografia......................................................................................................................365

Dodatek A J-zyk C w 3rodowisku j-zyka C++ ..................................................367

A.1. Wywołania funkcji ..................................................................................................367

A.2. Parametry funkcji ....................................................................................................368

A.3. Prototypy funkcji.....................................................................................................369

A.4. Przekazywanie parametrów przez referencj..........................................................370

A.5. Zmienna liczba parametrów....................................................................................371

A.6. Wska9niki funkcji....................................................................................................373

A.7. Słowo kluczowe const jako modyfikator typu ........................................................375

A.8. Interfejs z programami w jzyku C.........................................................................377

:wiczenia........................................................................................................................389

Bibliografia......................................................................................................................390

Dodatek B Reprezentacja figur geometrycznych w j-zyku C++ .........................391

Dodatek C Referencje jako warto3ci zwracane przez operatory.........................403

Dodatek D Kopiowanie „bit po bicie”...............................................................407

D.1. Dlaczego kopiowanie składowych nie rozwi6zuje problemu?................................408

Dodatek E Figury geometryczne i idiom symboliczny........................................409

Dodatek F Programowanie strukturalne w j-zyku C++ .....................................447

F.1. Programowanie strukturalne — wprowadzenie.......................................................447

F.2. Elementy programowania strukturalnego w jzyku C++ ........................................448

F.3. Alternatywa dla bloków z głboko zagniedonymi zakresami..............................451

F.4. Rozwaania na temat implementacji........................................................................455

:wiczenia........................................................................................................................456

Gra wykorzystuj6ca idiom strukturalny..........................................................................457

Bibliografia......................................................................................................................460

Spis rysunków ...............................................................................461

Spis listingów................................................................................463

Skorowidz......................................................................................467

Rozdział 9.

Emulacja jzyków

symbolicznych w C++

Jzyk C++ dysponuje mechanizmami umoliwiajcymi definiowanie abstrakcyjnych

typów danych i uywanie ich w programowaniu obiektowym. Jednak elastyczno!"

jzyków obiektowych wysokiego poziomu takich jak Smalltalk czy CLOS jest trudna

w jzyku C++ tak blisko zwizanym z jzykiem C. Zarówno w jzyku C, jak i C++

nazwa zmiennej zwizana jest z adresem opisywanego przez ni obiektu i tym samym

nie jest jedynie jego etykiet, która moe zosta" „odklejona” z jednego obiektu i przy-

porzdkowana innemu. Silne powizanie zmiennej z obiektem pozwala kompilatorowi

zapewni", e dana zmienna zawsze bdzie uywana z obiektem okre!lonego typu.

Wła!ciwo!" ta pozwala generowa" bardziej efektywny kod i zapobiega" uyciu obiektów

tam, gdzie nie były one spodziewane. Efektywno!" i zgodno!" typów osiga si jednak

kosztem elastyczno!ci działania programu — na przykład zmienna zadeklarowana

jako typu nie moe zosta" uyta podczas działania programu dla obiektu typu

, chocia oba typy s ze sob zgodne pod wzgldem zachowania.

Smalltalk i wikszo!" jzyków obiektowych bazujcych na jzyku Lisp dysponuje

dwiema wła!ciwo!ciami wykorzystujcymi lu/ne powizanie zmiennych i obiektów,

które nie s bezpo!rednio dostpne w jzyku C++, ale mog zosta" wyraone za pomoc

odpowiednich idiomów i styli programowania. Pierwsz z tych wła!ciwo!ci jest auto-

matyczne zarzdzanie pamici (zliczanie referencji lub zbieranie nieuytków). W jzy-

kach symbolicznych, gdzie zmienne s jedynie etykietami obiektów, czas istnienia

obiektów jest niezaleny od opisujcych je zmiennych. 3rodowiska programowania

w jzykach symbolicznych uywaj specjalnych technik pozwalajcych odzyska"

pami" zajmowan przez obiekty, do których nie istniej ju adne odwołania w pro-

gramie. W jzyku C++ moemy symulowa" takie rozwizanie, adresujc obiekty za

pomoc wska/ników. Utworzony w ten sposób dodatkowy poziom dostpu do obiektów

moe zosta" wykorzystany w celu automatyzacji zarzdzania pamici, co zostało

szczegółowo omówione w podrozdziałach 3.5 i 3.6.

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika: