c++. projektowanie systemów informatycznych. vademecum profesjonalisty pełna wersja.pdf

(5485 KB) Pobierz
1277652048.001.png
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
Spis treci
9
9.2. Typy podstawowe uyte w interfejsie.........................................................................498
9.2.1. Uycie typu short w interfejsie..........................................................................498
9.2.2. Uycie kwalifikatora unsigned w interfejsie .....................................................501
9.2.3. Zastosowanie typu long w interfejsie................................................................505
9.2.4. Zastosowanie typów float, double oraz long double w interfejsie.....................507
9.3. Funkcje specjalnego przeznaczenia.............................................................................508
9.3.1. Operatory konwersji..........................................................................................508
9.3.2. Semantyka warto"ci generowanych przez kompilator.......................................512
9.3.3. Destruktor..........................................................................................................513
9.4. Podsumowanie............................................................................................................515
+ $%,(*
10.1. Pola...........................................................................................................................521
10.1.1. Wyrównanie naturalne...................................................................................522
10.1.2. Uycie typów podstawowych w implementacji.............................................524
10.1.3. Uycie konstrukcji typedef w implementacji.................................................526
10.2. Definicje funkcji .......................................................................................................527
10.2.1. Samokontrola ................................................................................................527
10.2.2. Unikanie przypadków szczególnych .............................................................528
10.2.3. Podział zamiast powielania ...........................................................................530
10.2.4. Zbytnia przebiegło" nie popłaca..................................................................533
10.3. Zarz6dzanie pami2ci6................................................................................................533
10.3.1. Warto"ci stanu logicznego i fizycznego ........................................................538
10.3.2. Parametry fizyczne........................................................................................541
10.3.3. Systemy przydziału pami2ci..........................................................................545
10.3.4. Zarz6dzanie pami2ci6 na poziomie klasy ......................................................551
10.3.4.1. Dodawanie własnych mechanizmów zarz6dzania pami2ci6...........555
10.3.4.2. Zablokowana pami2......................................................................558
10.3.5. Zarz6dzanie pami2ci6 na poziomie obiektu...................................................562
10.4. Uycie szablonów w duych projektach ...................................................................567
10.4.1. Implementacje szablonów.............................................................................567
10.4.2. Zarz6dzanie pami2ci6 w szablonach..............................................................568
10.4.3. Wzorce a szablony.........................................................................................577
10.5. Podsumowanie..........................................................................................................579
%&'#
-(. !&(/!% !")
Protocol Hierarchy — struktury klas..................................................................................585
Cel.............................................................................................................................585
Znany te jako...........................................................................................................585
Motywacja.................................................................................................................585
Zakres zastosowania..................................................................................................589
Struktura....................................................................................................................590
Elementy składowe....................................................................................................590
Współpraca................................................................................................................591
Konsekwencje...........................................................................................................591
Implementacja...........................................................................................................592
Przykładowy kod.......................................................................................................603
Znane zastosowania...................................................................................................607
Pokrewne wzorce ......................................................................................................608

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika:

Zgłoś jeśli naruszono regulamin