[ Pobierz całość w formacie PDF ]
IDZ DO
PRZYK£ADOW
SPIS TRECI
C++. Projektowanie
systemów informatycznych.
Vademecum profesjonalisty
KATALOG KSI¥¯EK
KATALOG ONLINE
Autor: John Lakos
T³umaczenie: Wojciech Moch (rozdz. 1 – 4), Micha³ Dadan
(rozdz. 5, 6), Rados³aw Meryk (rozdz. 7 – 10, dod. A – C)
ISBN: 83-7361-173-8
Tytu³ orygina³u
Format: B5, stron: 688
ZAMÓW DRUKOWANY KATALOG
TWÓJ KOSZYK
DODAJ DO KOSZYKA
CENNIK I INFORMACJE
C++ nie jest tylko rozszerzeniem jêzyka C, ale wprowadza zupe³nie nowy model
programowania. Stopieñ skomplikowania C++ mo¿e byæ przyt³aczaj¹cy nawet dla
dowiadczonych programistów C, jednak zazwyczaj nie sprawia im problemów napisanie
i uruchomienie ma³ego, niebanalnego programu w C++. Niestety, brak dyscypliny
dopuszczalny przy tworzeniu ma³ych programów, zupe³nie nie sprawdza siê w du¿ych
projektach. Podstawowe u¿ycie technologii C++ nie wystarczy do budowy du¿ych
projektów. Na niezorientowanych czeka wiele pu³apek.
Ksi¹¿ka ta opisuje metody projektowania du¿ych systemów wysokiej jakoci.
Adresowana jest do dowiadczonych programistów C++ próbuj¹cych stworzyæ
architekturê ³atw¹ w obs³udze i mo¿liw¹ do ponownego wykorzystania. Nie zawarto
w niej teoretycznego podejcia do programowania. W tej ksi¹¿ce znajduj¹ siê praktyczne
wskazówki wyp³ywaj¹ce z wieloletnich dowiadczeñ ekspertów C++ tworz¹cych
ogromne systemy wielostanowiskowe. Autor pokazuje, jak nale¿y projektowaæ systemy,
nad którymi pracuj¹ setki programistów, sk³adaj¹ce siê z tysiêcy klas i prawdopodobnie
milionów linii kodu.
W ksi¹¿ce opisano:
• Tworzenie programów wieloplikowych w C++
• Konstruowanie komponentów
• Podzia³ projektu fizycznego na poziomy
• Ca³kowit¹ i czêciow¹ izolacjê, regu³y jej stosowania
• Tworzenie pakietów i ich podzia³ na poziomy
• Projektowanie funkcji
• Implementowanie metod
Dodatki do ksi¹¿ki opisuj¹ przydatny wzorzec projektowy — hierarchiê protoko³ów,
implementowanie interfejsu C++ zgodnego ze standardem ANSI C oraz pakiet s³u¿¹cy
do okrelania i analizowania zale¿noci.
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
 W.1. Od C do C++...............................................................................................................15
W.2. Jak uywa C++ do tworzenia duych projektów......................................................16
W.2.1. Zaleno"ci cykliczne........................................................................................16
W.2.2. Nadmierne zaleno"ci na etapie konsolidacji ..................................................18
W.2.3. Nadmierne zaleno"ci na etapie kompilacji.....................................................20
W.2.4. Globalna przestrze, nazw................................................................................22
W.2.5. Projekt logiczny i fizyczny..............................................................................23
W.3. Ponowne uycie...........................................................................................................25
W.4. Jako"..........................................................................................................................25
W.4.1. Kontrola jako"ci...............................................................................................27
W.4.2. Zapewnienie jako"ci........................................................................................27
W.5. Narz2dzia.....................................................................................................................27
W.6. Podsumowanie ............................................................................................................28
1.1. Programy wieloplikowe w C++ ....................................................................................31
1.1.1. Deklaracja a definicja..........................................................................................31
1.1.2. Konsolidacja (ł6czenie) wewn2trzna a zewn2trzna .............................................33
1.1.3. Pliki nagłówkowe (.h).........................................................................................36
1.1.4. Pliki implementacji (.c).......................................................................................37
1.2. Deklaracje typedef ........................................................................................................38
1.3. Instrukcje sprawdzaj6ce................................................................................................39
1.4. Kilka słów na temat stylu..............................................................................................40
1.4.1. Identyfikatory......................................................................................................41
1.4.1.1. Nazwy typów..........................................................................................41
1.4.1.2. Nazwy identyfikatorów składaj6ce si2 z wielu słów...............................42
1.4.1.3. Nazwy składowych klas.........................................................................42
1.4.2. Kolejno" ułoenia składowych w klasie............................................................44
1.5. Iteratory.........................................................................................................................46
1.6. Logiczna notacja projektu.............................................................................................52
1.6.1. Relacja Jest..........................................................................................................53
1.6.2. Relacja Uywa-W-Interfejsie..............................................................................54
1.6.3. Relacja Uywa-W-Implementacji.......................................................................56
1.6.3.1. Relacja Uywa........................................................................................58
1.6.3.2. Relacje Ma i Trzyma..............................................................................58
1.6.3.3. Relacja Był.............................................................................................59
 6
C++. Projektowanie systemów informatycznych. Vademecum profesjonalisty
1.7. Dziedziczenie i warstwy................................................................................................60
1.8. Minimalizacja................................................................................................................61
1.9. Podsumowanie..............................................................................................................62
2.1. Przegl6d ........................................................................................................................65
2.2. Dost2p do pól klasy.......................................................................................................66
2.3. Globalna przestrze, nazw.............................................................................................70
2.3.1. Dane globalne......................................................................................................70
2.3.2. Wolne funkcje.....................................................................................................72
2.3.3. Wyliczenia, stałe i deklaracje typedef.................................................................73
2.3.4. Makra preprocesora.............................................................................................74
2.3.5. Nazwy w plikach nagłówkowych........................................................................75
2.4. Kontrola doł6cze,.........................................................................................................77
2.5. Dodatkowa kontrola doł6cze,.......................................................................................79
2.6. Dokumentacja...............................................................................................................84
2.7. Sposoby nazywania identyfikatorów.............................................................................86
2.8. Podsumowanie..............................................................................................................87
3.1. Komponenty a klasy......................................................................................................93
3.2. Reguły projektów fizycznych......................................................................................100
3.3. Relacja ZaleyOd........................................................................................................108
3.4. Zaleno"ci implikowane..............................................................................................112
3.5. Wydobywanie rzeczywistych zaleno"ci....................................................................117
3.6. PrzyjaC, ......................................................................................................................119
3.6.1. PrzyjaC, na odległo" i zaleno"ci implikowane...............................................122
3.6.2. PrzyjaC, i oszustwo...........................................................................................124
3.7. Podsumowanie............................................................................................................126
!"#!
4.1. Metafora dla testowania oprogramowania ..................................................................129
4.2. Złoony podsystem.....................................................................................................130
4.3. Problemy z testowaniem „dobrych” interfejsów.........................................................134
4.4. Projektowanie zorientowane na testowalno".............................................................136
4.5. Testowanie pojedynczych modułów...........................................................................138
4.6. Acykliczne zaleno"ci fizyczne...................................................................................140
4.7. Numery poziomów......................................................................................................142
4.7.1. Gródła numeracji poziomów..............................................................................142
4.7.2. Uywanie numerów poziomów w oprogramowaniu.........................................144
4.8. Testowanie hierarchiczne i przyrostowe.....................................................................147
4.9. Testowanie złoonych podsystemów..........................................................................153
4.10. Testowalno" kontra testowanie................................................................................154
4.11. Cykliczne zaleno"ci fizyczne...................................................................................155
4.12. Suma zaleno"ci komponentów................................................................................156
4.13. Jako" projektu fizycznego.......................................................................................161
4.14. Podsumowanie..........................................................................................................167
5.1. Niektóre przyczyny cyklicznych zaleno"ci fizycznych.............................................169
5.1.1. Rozszerzenie .....................................................................................................170
5.1.2. Wygoda.............................................................................................................172
5.1.3. Wewn2trzna zaleno"......................................................................................176
Spis treci
7
5.2. Wyniesienie.................................................................................................................178
5.3. Obnienie....................................................................................................................187
5.4. Nieprzezroczyste wskaCniki........................................................................................199
5.5. Głupie dane.................................................................................................................206
5.6. Redundancja................................................................................................................216
5.7. Wywołania zwrotne ....................................................................................................219
5.8. Klasa-meneder...........................................................................................................231
5.9. Faktoring.....................................................................................................................235
5.10. Wynoszenie enkapsulacji..........................................................................................249
5.11. Podsumowanie..........................................................................................................260
$%!&
6.1. Od enkapsulacji do izolacji.........................................................................................262
6.1.1. Koszty powi6za, na etapie kompilacji..............................................................266
6.2. Konstrukcje w j2zyku C++ a zaleno"ci na etapie kompilacji ....................................267
6.2.1. Dziedziczenie (Jest) a zaleno"ci na etapie kompilacji .....................................268
6.2.2. Podział na warstwy (Ma/Trzyma) a zaleno"ci na etapie kompilacji................269
6.2.3. Funkcje inline a zaleno"ci na etapie kompilacji...............................................270
6.2.4. Składowe prywatne a zaleno"ci na etapie kompilacji......................................271
6.2.5. Składowe chronione a zaleno"ci na etapie kompilacji.....................................273
6.2.6. Funkcje składowe generowane przez kompilator a zaleno"ci
na etapie kompilacji.................................................................................................274
6.2.7. Dyrektywy include a zaleno"ci na etapie kompilacji.......................................275
6.2.8. Argumenty domy"lne a zaleno"ci na etapie kompilacji...................................277
6.2.9. Wyliczenia a zaleno"ci na etapie kompilacji...................................................277
6.3. Techniki cz2"ciowej izolacji.......................................................................................279
6.3.1. Rezygnacja z dziedziczenia prywatnego...........................................................279
6.3.2. Usuwanie osadzonych danych składowych.......................................................281
6.3.3. Usuwanie prywatnych funkcji składowych.......................................................282
6.3.4. Usuwanie składowych chronionych..................................................................290
6.3.5. Usuwanie prywatnych danych składowych.......................................................299
6.3.6. Usuwanie funkcji generowanych przez kompilator...........................................302
6.3.7. Usuwanie dyrektyw include..............................................................................302
6.3.8. Usuwanie argumentów domy"lnych..................................................................303
6.3.9. Usuwanie wylicze, ...........................................................................................305
6.4. Techniki całkowitej izolacji........................................................................................307
6.4.1. Klasa protokołu.................................................................................................308
6.4.2. W pełni izoluj6ca klasa konkretna.....................................................................317
6.4.3. Izoluj6ce komponenty otaczaj6ce......................................................................322
6.4.3.1. Pojedyncze komponenty otaczaj6ce.....................................................323
6.4.3.2. Wielokomponentowe warstwy otaczaj6ce............................................331
6.5. Interfejs proceduralny.................................................................................................338
6.5.1. Architektura interfejsu proceduralnego.............................................................339
6.5.2. Tworzenie i usuwanie nieprzezroczystych obiektów ........................................341
6.5.3. Uchwyty............................................................................................................342
6.5.4. Uzyskiwanie dost2pu do nieprzezroczystych obiektów i manipulowanie nimi....346
6.5.5. Dziedziczenie a nieprzezroczyste obiekty.........................................................351
6.6. Izolowa czy nie izolowa..........................................................................................354
6.6.1. Koszt izolacji.....................................................................................................354
6.6.2. Kiedy nie naley izolowa.................................................................................356
6.6.3. Jak izolowa......................................................................................................360
6.6.4. Do jakiego stopnia naley izolowa..................................................................366
6.7. Podsumowanie............................................................................................................373
8
C++. Projektowanie systemów informatycznych. Vademecum profesjonalisty
' (''
7.1. Od komponentów do pakietów ...................................................................................378
7.2. Zarejestrowane prefiksy pakietów...............................................................................385
7.2.1. Potrzeba stosowania prefiksów .........................................................................385
7.2.2. Przestrzenie nazw..............................................................................................387
7.2.3. Zachowanie integralno"ci pakietu.....................................................................391
7.3. Podział pakietów na poziomy .....................................................................................393
7.3.1. Znaczenie podziału pakietów na poziomy.........................................................393
7.3.2. Techniki podziału pakietów na poziomy...........................................................394
7.3.3. Podział systemu.................................................................................................396
7.3.4. Wytwarzanie oprogramowania w wielu o"rodkach...........................................398
7.4. Izolacja pakietów........................................................................................................399
7.5. Grupy pakietów...........................................................................................................402
7.6. Proces wydawania oprogramowania...........................................................................406
7.6.1. Struktura wydania .............................................................................................408
7.6.2. Łaty...................................................................................................................413
7.7. Program main..............................................................................................................415
7.8. Faza startu...................................................................................................................421
7.8.1. Strategie inicjalizacji.........................................................................................423
7.8.1.1. Technika „przebudzenia” w stanie zainicjowania ................................424
7.8.1.2. Technika jawnego wywoływania funkcji init.......................................424
7.8.1.3. Technika wykorzystania specjalnego licznika......................................426
7.8.1.4. Technika sprawdzania za kadym razem..............................................431
7.8.2. Porz6dkowanie..................................................................................................432
7.8.3. Przegl6d.............................................................................................................433
7.9. Podsumowanie............................................................................................................434
!"#$
) &((*
8.1. Abstrakcje i komponenty ............................................................................................439
8.2. Projekt interfejsu komponentu....................................................................................440
8.3. Poziomy enkapsulacji..................................................................................................444
8.4. Pomocnicze klasy implementacyjne............................................................................454
8.5. Podsumowanie............................................................................................................459
&(#(!&
9.1. Specyfikacja interfejsu funkcji....................................................................................462
9.1.1. Operator czy metoda?........................................................................................462
9.1.2. Wolny operator czy składowa klasy?................................................................468
9.1.3. Metoda wirtualna czy niewirtualna?..................................................................472
9.1.4. Metoda czysto wirtualna czy nie czysto wirtualna? ..........................................476
9.1.5. Metoda statyczna czy niestatyczna?..................................................................477
9.1.6. Metody stałe czy modyfikowalne?....................................................................478
9.1.7. Metody publiczne, chronione czy prywatne......................................................483
9.1.8. Zwracanie wyniku przez warto", referencj2 czy wskaCnik? ............................484
9.1.9. Zwracanie warto"ci typu const czy nie-const? ..................................................487
9.1.10. Argument opcjonalny czy obowi6zkowy?.......................................................488
9.1.11. Przekazywanie argumentów przez warto", referencj2 lub wskaCnik .............490
9.1.12. Przekazywanie argumentów jako const lub nie-const.....................................495
9.1.13. Funkcja zaprzyjaCniona czy niezaprzyjaCniona?.............................................496
9.1.14. Funkcja inline czy nie inline?..........................................................................497
[ Pobierz całość w formacie PDF ]