C++ Projektowanie systemow informatycznych Vad Profesj.pdf
(
487 KB
)
Pobierz
C:\Andrzej\PDF\ABC nagrywania p³yt CD\1 strona.cdr
IDZ DO
PRZYK£ADOW
Y ROZDZIA£
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
:
Large-Scale C++ Software Design
Format: B5, stron: 688
Przyk³ady na ftp: 52 kB
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
Plik z chomika:
Ravel25
Inne pliki z tego folderu:
Asembler dla procesorow Intel Vademecum profesjonalisty.pdf
(400 KB)
Asembler cwiczenia praktyczne.pdf
(358 KB)
Architektura systemow zarzadzania przedsiebiorstwem Wzorce projektowe.pdf
(829 KB)
Architektura oprogramowania Metody oceny oraz analiza przypadkow.pdf
(429 KB)
Aplikacje w Visual C++ 2005 Przyklady.pdf
(296 KB)
Inne foldery tego chomika:
(X) HTML
algorytmy i struktury danych
asembler
C++
Core JAVA2 Podstawy
Zgłoś jeśli
naruszono regulamin