C_Projektowanie_systemow_informatycznych_Vademecum_profesjonalisty_cpsivp.pdf

(474 KB) Pobierz
IDZ DO
PRZYK£ADOWY ROZDZIA£
SPIS TRE CI
KATALOG KSI¥¯EK
KATALOG ONLINE
ZAMÓW DRUKOWANY KATALOG
C++. Projektowanie
systemów informatycznych.
Vademecum profesjonalisty
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
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
do wiadczonych 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 jako ci.
Adresowana jest do do wiadczonych programistów C++ próbuj¹cych stworzyæ
architekturê ³atw¹ w obs³udze i mo¿liw¹ do ponownego wykorzystania. Nie zawarto
w niej teoretycznego podej cia do programowania. W tej ksi¹¿ce znajduj¹ siê praktyczne
wskazówki wyp³ywaj¹ce z wieloletnich do wiadczeñ 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 okre lania i analizowania zale¿no ci.
TWÓJ KOSZYK
DODAJ DO KOSZYKA
CENNIK I INFORMACJE
ZAMÓW INFORMACJE
O NOWO CIACH
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
5RKU VTG EK
2T\GFOQYC
9RTQYCF\GPKG
W.1. Od C do C++ ............................................................................................................... 15
W.2. Jak u ywać C++ do tworzenia du ych projektów ...................................................... 16
W.2.1. Zale ności cykliczne........................................................................................ 16
W.2.2. Nadmierne zale ności na etapie konsolidacji .................................................. 18
W.2.3. Nadmierne zale ności na etapie kompilacji..................................................... 20
W.2.4. Globalna przestrzeń nazw................................................................................ 22
W.2.5. Projekt logiczny i fizyczny .............................................................................. 23
W.3. Ponowne u ycie........................................................................................................... 25
W.4. Jakość .......................................................................................................................... 25
W.4.1. Kontrola jakości............................................................................................... 27
W.4.2. Zapewnienie jakości ........................................................................................ 27
W.5. Narzędzia..................................................................................................................... 27
W.6. Podsumowanie ............................................................................................................ 28
%\ú è +
4Q\F\KC
2QFUVCY[
9UVúR
1.1. Programy wieloplikowe w C++ .................................................................................... 31
1.1.1. Deklaracja a definicja.......................................................................................... 31
1.1.2. Konsolidacja (łączenie) wewnętrzna a zewnętrzna ............................................. 33
1.1.3. Pliki nagłówkowe (.h) ......................................................................................... 36
1.1.4. Pliki implementacji (.c) ....................................................................................... 37
1.2. Deklaracje typedef ........................................................................................................ 38
1.3. Instrukcje sprawdzające ................................................................................................ 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ładające się z wielu słów...............................42
1.4.1.3. Nazwy składowych klas .........................................................................42
1.4.2. Kolejność uło enia 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 U ywa-W-Interfejsie .............................................................................. 54
1.6.3. Relacja U ywa-W-Implementacji ....................................................................... 56
1.6.3.1. Relacja U ywa........................................................................................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
4Q\F\KC
2QFUVCYQYG TGIW [
2.1. Przegląd ........................................................................................................................ 65
2.2. Dostęp 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łączeń ......................................................................................................... 77
2.5. Dodatkowa kontrola dołączeń....................................................................................... 79
2.6. Dokumentacja ............................................................................................................... 84
2.7. Sposoby nazywania identyfikatorów............................................................................. 86
2.8. Podsumowanie .............................................................................................................. 87
%\ú è ++
4Q\F\KC
2TQLGMV HK\[E\P[
-QORQPGPV[
3.1. Komponenty a klasy...................................................................................................... 93
3.2. Reguły projektów fizycznych...................................................................................... 100
3.3. Relacja Zale yOd........................................................................................................ 108
3.4. Zale ności implikowane.............................................................................................. 112
3.5. Wydobywanie rzeczywistych zale ności .................................................................... 117
3.6. Przyjaźń ...................................................................................................................... 119
3.6.1. Przyjaźń na odległość i zale ności implikowane............................................... 122
3.6.2. Przyjaźń i oszustwo........................................................................................... 124
3.7. Podsumowanie ............................................................................................................ 126
4Q\F\KC
*KGTCTEJKC HK\[E\PC
4.1. Metafora dla testowania oprogramowania .................................................................. 129
4.2. Zło ony 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 zale ności fizyczne................................................................................... 140
4.7. Numery poziomów...................................................................................................... 142
4.7.1. Źródła numeracji poziomów.............................................................................. 142
4.7.2. U ywanie numerów poziomów w oprogramowaniu ......................................... 144
4.8. Testowanie hierarchiczne i przyrostowe ..................................................................... 147
4.9. Testowanie zło onych podsystemów .......................................................................... 153
4.10. Testowalność kontra testowanie................................................................................ 154
4.11. Cykliczne zale ności fizyczne................................................................................... 155
4.12. Suma zale ności komponentów ................................................................................ 156
4.13. Jakość projektu fizycznego ....................................................................................... 161
4.14. Podsumowanie .......................................................................................................... 167
4Q\F\KC
2QF\KC PC RQ\KQO[
5.1. Niektóre przyczyny cyklicznych zale ności fizycznych ............................................. 169
5.1.1. Rozszerzenie ..................................................................................................... 170
5.1.2. Wygoda ............................................................................................................. 172
5.1.3. Wewnętrzna zale ność ...................................................................................... 176
Spis treści
7
5.2. Wyniesienie................................................................................................................. 178
5.3. Obni enie .................................................................................................................... 187
5.4. Nieprzezroczyste wskaźniki........................................................................................ 199
5.5. Głupie dane ................................................................................................................. 206
5.6. Redundancja................................................................................................................ 216
5.7. Wywołania zwrotne .................................................................................................... 219
5.8. Klasa-mened er........................................................................................................... 231
5.9. Faktoring..................................................................................................................... 235
5.10. Wynoszenie enkapsulacji .......................................................................................... 249
5.11. Podsumowanie .......................................................................................................... 260
4Q\F\KC
+\QNCELC
6.1. Od enkapsulacji do izolacji ......................................................................................... 262
6.1.1. Koszty powiązań na etapie kompilacji .............................................................. 266
6.2. Konstrukcje w języku C++ a zale ności na etapie kompilacji .................................... 267
6.2.1. Dziedziczenie (Jest) a zale ności na etapie kompilacji ..................................... 268
6.2.2. Podział na warstwy (Ma/Trzyma) a zale ności na etapie kompilacji ................ 269
6.2.3. Funkcje inline a zale ności na etapie kompilacji............................................... 270
6.2.4. Składowe prywatne a zale ności na etapie kompilacji ...................................... 271
6.2.5. Składowe chronione a zale ności na etapie kompilacji ..................................... 273
6.2.6. Funkcje składowe generowane przez kompilator a zale ności
na etapie kompilacji ................................................................................................. 274
6.2.7. Dyrektywy include a zale ności na etapie kompilacji....................................... 275
6.2.8. Argumenty domyślne a zale ności na etapie kompilacji ................................... 277
6.2.9. Wyliczenia a zale ności na etapie kompilacji ................................................... 277
6.3. Techniki częś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 izolująca klasa konkretna..................................................................... 317
6.4.3. Izolujące komponenty otaczające...................................................................... 322
6.4.3.1. Pojedyncze komponenty otaczające .....................................................323
6.4.3.2. Wielokomponentowe warstwy otaczające............................................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 dostępu 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 nale y izolować................................................................................. 356
6.6.3. Jak izolować ...................................................................................................... 360
6.6.4. Do jakiego stopnia nale y izolować .................................................................. 366
6.7. Podsumowanie ............................................................................................................ 373
8
C++. Projektowanie systemów informatycznych. Vademecum profesjonalisty
4Q\F\KC
2CMKGV[
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 ka dym razem..............................................431
7.8.2. Porządkowanie .................................................................................................. 432
7.8.3. Przegląd............................................................................................................. 433
7.9. Podsumowanie ............................................................................................................ 434
%\ú è +++
4Q\F\KC
<CICFPKGPKC FQV[E\æEG RTQLGMVW NQIKE\PGIQ
2TQLGMVQYCPKG MQORQPGPVÎY
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
4Q\F\KC
2TQLGMVQYCPKG HWPMELK
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ść, referencję czy wskaźnik? ............................ 484
9.1.9. Zwracanie wartości typu const czy nie-const? .................................................. 487
9.1.10. Argument opcjonalny czy obowiązkowy?....................................................... 488
9.1.11. Przekazywanie argumentów przez wartość, referencję lub wskaźnik ............. 490
9.1.12. Przekazywanie argumentów jako const lub nie-const ..................................... 495
9.1.13. Funkcja zaprzyjaźniona czy niezaprzyjaźniona? ............................................. 496
9.1.14. Funkcja inline czy nie inline?.......................................................................... 497

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika:

Zgłoś jeśli naruszono regulamin