[ Pobierz całość w formacie PDF ]
IDZ DO
PRZYK£ADOW
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³
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
  6
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
7
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.
   [ Pobierz całość w formacie PDF ]