C++ Strategie i taktyki Vademecum profesjonalisty(1).pdf

(1785 KB) Pobierz
C:\Andrzej\PDF\ABC nagrywania p³yt CD\1 strona.cdr
IDZ DO
PRZYK£ADOW Y ROZDZIA£
C++. Strategie i taktyki.
Vademecum profesjonalisty
SPIS TRECI
KATALOG KSI¥¯EK
Autor: Robert B. Murray
T³umaczenie: Przemys³aw Steæ
ISBN: 83-7361-323-4
Format: B5, stron: 240
KATALOG ONLINE
ZAMÓW DRUKOWANY KATALOG
TWÓJ KOSZYK
DODAJ DO KOSZYKA
Poznanie ruchów figur szachowych to dopiero pierwszy krok w nauce tej gry.
Aby j¹ opanowaæ, trzeba zrozumieæ strategie i taktyki, które wp³ywaj¹ na ka¿dy ruch.
To samo dotyczy jêzyka C++. Znajomoæ w³aciwych strategii pomaga unikaæ pu³apek
i pracowaæ o wiele skuteczniej. Rob Murray dziel¹c siê swoim dowiadczeniem pomaga
programistom C++ wykonaæ nastêpny krok w kierunku tworzenia wydajnych aplikacji.
Licznie wystêpuj¹ce w ca³ej ksi¹¿ce przyk³ady kodu maj¹ na celu zilustrowanie
przydatnych strategii programistycznych i ostrzec przed nabyciem niebezpiecznych
nawyków. Aby dodatkowo u³atwiæ przyswajanie nowych umiejêtnoci, ka¿dy rozdzia³
koñczy siê list¹ poruszonych w nim kluczowych zagadnieñ oraz pytaniami maj¹cymi
spowodowaæ przemylenia i dyskusje.
Ksi¹¿ka przedstawia miêdzy innymi:
• Tworzenie w³aciwych abstrakcji dla projektu i przekszta³canie abstrakcji
w klasy C++
• Mechanizmy dziedziczenia pojedynczego i wielokrotnego
• Metody tworzenia klas
• Szczegó³owy opis mechanizmu szablonów
• Wskazówki dotycz¹ce stosowania wyj¹tków
• Metody tworzenia kodu nadaj¹cego siê do wielokrotnego wykorzystania
• Przenoszenie programów z jêzyka C do C++
Robert B. Murray jest wicedyrektorem ds. in¿ynierii oprogramowania w firmie
Quantitative Data Systems dostarczaj¹cej niestandardowych rozwi¹zañ z zakresu
oprogramowania dla czo³owych firm. Wczenie pracowa³ w AT&T Bell Labs, gdzie bra³
udzia³ w rozwoju jêzyka C++, jego kompilatorów i bibliotek. Jest pierwszym redaktorem
magazynu „The C++ Report”. Od 1987 prowadzi zajêcia dotycz¹ce jêzyka C++ na
konferencjach naukowych i technicznych.
CENNIK I INFORMACJE
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
329225141.001.png 329225141.002.png 329225141.003.png
1.1. Abstrakcja numeru telefonu............................................................................................17
1.2. Zwizki midzy abstrakcjami.........................................................................................19
1.3. Problem warunków brzegowych ....................................................................................24
1.4. Projektowanie z wykorzystaniem kart CRC...................................................................25
1.5. W skrócie........................................................................................................................26
1.6. Pytania ............................................................................................................................26
2.1. Konstruktory...................................................................................................................27
2.2. Przypisanie......................................................................................................................34
2.3. Dane publiczne ...............................................................................................................36
2.4. Niejawne konwersje typów.............................................................................................40
2.5. Operatory przeci0one — składowe czy nie?.................................................................44
2.6. Przeci0enie, argumenty domy5lne i wielokropek .........................................................47
2.7. Słowo kluczowe const ....................................................................................................48
2.8. Zwracanie referencji .......................................................................................................54
2.9. Konstruktory statyczne ...................................................................................................55
2.10. W skrócie......................................................................................................................56
2.11. Pytania ..........................................................................................................................57
! "#
3.1. Klasa Lancuch.................................................................................................................60
3.2. Unikanie kopiowania przez zastosowanie liczników u0ycia..........................................61
3.3. Zapobieganie powtórnym kompilacjom — „Kot z Cheshire”........................................66
3.4. Stosowanie uchwytów w celu ukrycia szczegółów projektu..........................................68
3.5. Implementacje wielokrotne.............................................................................................69
3.6. Uchwyty jako obiekty.....................................................................................................72
3.7. Podsumowanie................................................................................................................73
3.8. W skrócie........................................................................................................................73
3.9. Pytania ............................................................................................................................73
$ %
4.1. Zwizek generalizacji (specjalizacji)..............................................................................75
4.2. Dziedziczenie publiczne .................................................................................................78
4.3. Dziedziczenie prywatne..................................................................................................78
4.4. Dziedziczenie chronione.................................................................................................82
4.5. Zgodno5? z abstrakcjami klasy bazowej.........................................................................83
4.6. Funkcje czysto wirtualne ................................................................................................85
6
C++. Strategie i taktyki. Vademecum profesjonalisty
4.7. Szczegóły i pułapki zwizane z dziedziczeniem ............................................................87
4.8. W skrócie........................................................................................................................90
4.9. Pytania ............................................................................................................................90
%
5.1. Dziedziczenie wielokrotne jako iloczyn zbiorów...........................................................91
5.2. Wirtualne klasy bazowe..................................................................................................96
5.3. Pewne szczegóły dotyczce dziedziczenia wielokrotnego.............................................99
5.4. W skrócie......................................................................................................................101
5.5. Pytania ..........................................................................................................................101
& '(!
6.1. Interfejs chroniony........................................................................................................103
6.2. Czy nale0y projektowa? pod ktem dziedziczenia?......................................................106
6.3. Projektowanie pod ktem dziedziczenia — kilka przykładów.....................................111
6.4. Podsumowanie..............................................................................................................116
6.5. W skrócie......................................................................................................................116
6.6. Pytania ..........................................................................................................................117
)
7.1. Szablon klasy Para........................................................................................................119
7.2. Kilka szczegółów dotyczcych szablonów...................................................................122
7.3. Konkretyzacja szablonu................................................................................................123
7.4. Inteligentne wskaAniki..................................................................................................125
7.5. Argumenty wyra0eniowe szablonów............................................................................131
7.6. Szablony funkcji ...........................................................................................................132
7.7. W skrócie......................................................................................................................135
7.8. Pytania ..........................................................................................................................136
* ) !
8.1. Klasy kontenerowe wykorzystujce szablony..............................................................139
8.2. Przykład — klasa Blok .................................................................................................141
8.3. Szczegóły projektowe klasy Blok.................................................................................143
8.4. Kontenery z iteratorami — klasa Lista.........................................................................148
8.5. Zagadnienia dotyczce projektowania iteratorów ........................................................154
8.6. Zagadnienia dotyczce wydajno5ci ..............................................................................157
8.7. Ograniczenia dotyczce argumentów szablonów.........................................................160
8.8. Specjalizacje szablonów ...............................................................................................162
8.9. W skrócie......................................................................................................................168
8.10. Pytania ........................................................................................................................168
+,-./
9.1. Poznanie i nabycie ........................................................................................................172
9.2. Odporno5?.....................................................................................................................173
9.3. Zarzdzanie pamici ...................................................................................................179
9.4. Alternatywne metody alokacji pamici ........................................................................181
9.5. Przekazywanie argumentów do operatora new ............................................................184
9.6. Zarzdzanie zasobami zewntrznymi...........................................................................187
9.7. Znajdowanie błdów pamici.......................................................................................187
9.8. Konflikty nazw .............................................................................................................192
9.9. Wydajno5? ....................................................................................................................195
9.10. Nie zgaduj — zmierz!.................................................................................................195
9.11. Algorytmy...................................................................................................................196
9.12. Wskie gardła w dynamicznej alokacji pamici.........................................................197
9.13. Funkcje rozwijane w miejscu wywołania...................................................................202
Spis treci
7
9.14. Prawo Tiemanna .........................................................................................................204
9.15. W skrócie....................................................................................................................204
9.16. Pytania ........................................................................................................................205
( '(
10.1. Sprostowanie...............................................................................................................209
10.2. Dlaczego wyjtki?.......................................................................................................209
10.3. Przykład wyjtku ........................................................................................................212
10.4. Wyjtki powinny by? wyjtkowe ...............................................................................213
10.5. Zrozumie? wyjtki......................................................................................................215
10.6. Oszacowanie winy......................................................................................................215
10.7. Projektowanie obiektu wyjtku ..................................................................................217
10.8. W skrócie....................................................................................................................219
10.9. Pytania ........................................................................................................................219
0122
11.1. Wybór jzyka C++......................................................................................................221
11.2. Przyswajanie C++.......................................................................................................223
11.3. Projektowanie i implementacja...................................................................................224
11.4. Tworzenie bazy zasobów............................................................................................226
11.5. Uwagi koFcowe ..........................................................................................................227
11.6. W skrócie....................................................................................................................227
11.7. Pytania ........................................................................................................................228
)
Rozdział 4.
Wiele dyskusji dotyczcych dziedziczenia rozpoczyna si od objanienia reguł jzyka.
Chocia poznanie tych reguł jest niezbdne do korzystania z samego mechanizmu, to
najpierw powinnimy si upewni!, e rozumiemy, gdzie w projekcie dziedziczenie po-
winno zosta! zastosowane. Programy z nieodpowiednio zaprojektowanym dziedzicze-
niem mona wprawdzie doprowadzi! do kompilacji, lecz bd one trudne do zrozumienia
i utrzymania.
Dziedzicznie powinno zosta! zastosowane w przypadku, gdy nowa klasa (klasa po-
chodna) opisuje pewien zbiór obiektów, który jest podzbiorem obiektów opisywanych
przez klas bazow. Zaleno! ta jest zwizkiem generalizacji (lub specjalizacji):
Kady obiekt typu jest równie obiektem typu (zauwamy, e relacja
odwrotna nie jest prawdziwa — mog istnie! obiekty typu , które nie s obiektami
typu ). Kada operacja, któr mona zastosowa! do obiektu typu powinna
równie mie! sens przy zastosowaniu do obiektu typu (tj. funkcje składowe klasy
bazowej mog by! wywoływane dla obiektów klasy pochodnej). W klasie pochodnej
mona zmieni! implementacj funkcji składowej przez przesłonicie jej, lecz operacja
pojciowa powinna nadal mie! sens w klasie pochodnej. Kady pojazd mona przyspie-
szy! — rower bdzie korzystał z innej implementacji tej operacji ni pocig, lecz operacja
pojciowa bdzie taka sama.
Dziedziczenie nie powinno by! stosowane w przypadku, gdy klasa bazowa jest składni-
kiem obiektu opisywanego przez klas pochodn:

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika:

Zgłoś jeśli naruszono regulamin