c++. styl programowania full.pdf
(
14942 KB
)
Pobierz
718393583 UNPDF
IDZ DO
PRZYK£ADOW
Y ROZDZIA£
C++. Styl
SPIS TRECI
programowania
KATALOG KSI¥¯EK
Autor: Tom Cargill
T³umaczenie: Adam Majczak
ISBN: 83-7361-321-8
Tytu³ orygina³
u:
C++ Programming Style
Format: B5, stron: 224
KATALOG ONLINE
ZAMÓW DRUKOWANY KATALOG
TWÓJ KOSZYK
C++ wspomaga programowanie w du¿ej skali, pozwalaj¹c na precyzyjne wyra¿enie
wspó³zale¿noci pomiêdzy ró¿nymi czêciami programu. Dlatego zakres pojêciowy
techniki i stylu programowania w C++ wykracza poza tradycyjne jego pojmowanie
w odniesieniu do programowania w ma³ej skali, sprowadzaj¹cego siê do szczegó³ów
kodowania wiersz po wierszu.
Autor dowodzi, ¿e nieprzemylane stosowanie z³o¿onych i zaawansowanych technik
programowania mo¿e prowadziæ do tworzenia chaotycznych, niezrozumia³ych i mêtnych
konstrukcji, stanowi¹cych zarazem czêsto rozwi¹zania mniej efektywne, ni¿ prostsze
i zrozumia³e konstrukcje alternatywne. Tom Cargill dokonuje przeredagowania licznych
programów, stosuj¹c techniki pozwalaj¹ce na udoskonalenie kodu, pocz¹wszy
od poprawy spójnoci, po usuniecie zbêdnego, nadmiarowego dziedziczenia.
Sposób prezentacji zagadnieñ rozpoczyna siê od przegl¹du oryginalnego kodu,
który mo¿esz samodzielnie oceniæ i przeanalizowaæ, rozwa¿aj¹c mo¿liwe alternatywne
podejcia do przedstawionych zagadnieñ programistycznych. Te w³asne przemylenia
mo¿esz nastêpnie porównaæ z analizami i wnioskami Autora.
Na podstawie przyk³adów formu³owane s¹ uniwersalne regu³y i zasady tworzenia kodu
i projektowania programów. Zrozumienie i umiejêtne stosowanie tych regu³ pomo¿e
profesjonalnym programistom projektowaæ i pisaæ lepsze programy w C++.
Kolejne rozdzia³y powiêcone s¹ nastêpuj¹cym zagadnieniom:
• Abstrakcja —- pojêcia i modele abstrakcyjne
• Spójnoæ
• Zbêdne dziedziczenie
• Funkcje wirtualne
• Przeci¹¿anie operatorów
• Nak³adki typu „wrapper”
• Efektywnoæ
Po wprowadzeniu i zilustrowaniu regu³ programowania w pierwszych siedmiu
rozdzia³ach, Tom Cargill prezentuje praktyczne studium, w trakcie którego pojedynczy
przyk³adowy program przechodzi kolejne transformacje, które pozwalaj¹ poprawiæ
jego ogóln¹ jakoæ przy jednoczesnym zredukowaniu wielkoci kodu. Konkluzjê ksi¹¿ki
stanowi rozdzia³ powiêcony wielokrotnemu dziedziczeniu.
Ksi¹¿ka Toma Cargilla to nie tylko cenne ród³o wiedzy dla zaawansowanych
programistów — przyda siê ona równie¿ studentom informatyki i pokrewnych kierunków,
zainteresowanych zdobyciem profesjonalnych umiejêtnoci programistycznych.
DODAJ DO KOSZYKA
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
Spis treci
Przedmowa...............................................................................................................7
Wprowadzenie .........................................................................................................9
1
Abstrakcja..............................................................................................................15
Przykład techniki programowania: ceny komputerów...................................................................................... 15
Poszukiwanie wspólnego pojcia abstrakcyjnego............................................................................................. 19
Ró"nice pomidzy klasami................................................................................................................................ 22
Powtórnie wprowadzamy do programu dziedziczenie...................................................................................... 26
Wyeliminowanie typów wyliczeniowych......................................................................................................... 27
Podsumowanie .................................................................................................................................................. 30
Bibliografia ....................................................................................................................................................... 31
+wiczenie.......................................................................................................................................................... 31
2.
Spójno kodu........................................................................................................35
Przykład techniki programowania: klasa string................................................................................................ 36
Precyzyjnie zdefiniowany stan obiektu............................................................................................................. 37
Spójno-. fizycznego stanu obiektu ................................................................................................................... 38
Niezmienne warunki, czyli inwariancja klas..................................................................................................... 39
Konsekwentne stosowanie dynamicznego zarz3dzania pamici3..................................................................... 41
Zwolnienie dynamicznie przyporz3dkowanej pamici..................................................................................... 43
Przykład techniki programowania: drugie podej-cie do tego samego problemu.............................................. 44
Podsumowanie .................................................................................................................................................. 50
Bibliografia ....................................................................................................................................................... 51
+wiczenia.......................................................................................................................................................... 51
3.
Zb"dne dziedziczenie.............................................................................................55
Przykład techniki programowania: stos ............................................................................................................ 55
Reguły widoczno-ci nazw w procesie dziedziczenia........................................................................................ 59
Relacje tworzone poprzez dziedziczenie........................................................................................................... 60
4
SPIS TRECI
Enkapsulacja...................................................................................................................................................... 65
Interfejs a implementacja.................................................................................................................................. 67
Zastosowanie szablonów................................................................................................................................... 71
Podsumowanie .................................................................................................................................................. 73
Bibliografia ....................................................................................................................................................... 73
+wiczenie.......................................................................................................................................................... 74
4.
Funkcje wirtualne ..................................................................................................75
Przykład techniki programowania: problem pojazdów i gara"y....................................................................... 75
Spójno-. kodu................................................................................................................................................... 79
Destruktory klas bazowych............................................................................................................................... 81
Dziedziczenie.................................................................................................................................................... 82
Sprz"enie ......................................................................................................................................................... 85
Podsumowanie .................................................................................................................................................. 91
Bibliografia ....................................................................................................................................................... 92
+wiczenie.......................................................................................................................................................... 92
5.
Przeci%&anie operatorów........................................................................................93
Przeci3"anie operatorów — podstawy.............................................................................................................. 93
Przykład techniki programowania: tablica plików FileArray ........................................................................... 98
Dziedziczenie implementacji .......................................................................................................................... 105
Programistyczny dylemat — jak lepiej: przeci3"one operatory czy metody.................................................. 110
Podsumowanie ................................................................................................................................................ 112
Bibliografia ..................................................................................................................................................... 112
+wiczenia........................................................................................................................................................ 112
6
Klasy otaczaj%ce (ang. wrappers) ........................................................................113
Biblioteka C .................................................................................................................................................... 113
Przykład techniki programowania: klasa otaczaj3ca dla struktury dirent w C++........................................... 114
Wiele obiektów klasy Directory...................................................................................................................... 116
Gdy zawodzi konstruktor................................................................................................................................ 119
Publiczny dostp do stanu obiektu.................................................................................................................. 121
Dodatkowy argument słu"3cy obsłudze błdów............................................................................................. 123
Podsumowanie ................................................................................................................................................ 127
Bibliografia ..................................................................................................................................................... 128
+wiczenie........................................................................................................................................................ 128
7.
Efektywno.........................................................................................................129
Przykład techniki programowania: klasa BigInt............................................................................................. 130
Egzaminujemy klas BigInt............................................................................................................................ 136
Długo-. dynamicznych ła?cuchów znaków ................................................................................................... 138
Liczba dynamicznie zapamitywanych ła?cuchów znaków........................................................................... 140
Kod klienta...................................................................................................................................................... 144
Modyfikujemy klas BigInt ............................................................................................................................ 145
SPIS TRECI
5
Podsumowanie ................................................................................................................................................ 151
Bibliografia ..................................................................................................................................................... 152
+wiczenia........................................................................................................................................................ 152
8.
Studium praktyczne .............................................................................................153
Przykład techniki programowania: Finite State Machine, czyli automat stanów sko?czonych ..................... 153
Zainicjowanie.................................................................................................................................................. 158
Sprz"enia ....................................................................................................................................................... 165
Spójno-........................................................................................................................................................... 169
Moduły kontra abstrakcyjne typy danych....................................................................................................... 172
Warto-. kontra zachowanie ............................................................................................................................ 175
Uogólnienie..................................................................................................................................................... 180
Bibliografia ..................................................................................................................................................... 184
+wiczenia........................................................................................................................................................ 185
9
Dziedziczenie wielokrotne...................................................................................187
Niejednoznaczno-ci w mechanizmie wielokrotnego dziedziczenia................................................................ 187
Skierowane niecykliczne grafy hierarchii dziedziczenia ................................................................................ 189
Eksplorujemy wirtualne klasy bazowe............................................................................................................ 193
Przykład techniki programowania: klasa Monitor.......................................................................................... 200
Przykład techniki programowania: wirtualna klasa bazowa........................................................................... 204
Protokół powiadomie? zwrotnych i przydatne wielokrotne dziedziczenie..................................................... 210
Podsumowanie ................................................................................................................................................ 213
Bibliografia ..................................................................................................................................................... 213
+wiczenia........................................................................................................................................................ 213
10.
Zbiorcza lista reguł ..............................................................................................215
Rozdział 1.: „Abstrakcja”................................................................................................................................ 215
Rozdział 2.: „Spójno-. kodu” ......................................................................................................................... 215
Rozdział 3.: „Zbdne dziedziczenie” .............................................................................................................. 216
Rozdział 4.: „Funkcje wirtualne”.................................................................................................................... 216
Rozdział 5.: „Przeci3"anie operatorów”.......................................................................................................... 216
Rozdział 6.: „Klasy otaczaj3ce (ang. wrappers)”............................................................................................ 216
Rozdział 7.: „Efektywno-.”............................................................................................................................ 217
Rozdział 8.: „Studium praktyczne”................................................................................................................. 217
Rozdział 9.: „Dziedziczenie wielokrotne” ...................................................................................................... 217
Skorowidz............................................................................................................219
Zbdne dziedziczenie
Chocia w rozdziale 2. uwanie rozrónialimy interfejs klasy i implementacj klasy, nie czynili-
my tego w kontekcie dziedziczenia. Aby dokładnie zrozumie$ relacj dziedziczenia pomidzy klas%
pochodn% a jej klas% bazow%, musimy rozpatrywa$ cz$ interfejsow% i cz$ implementacyjn% klasy
w sposób odrbny. W tym rozdziale przeanalizujemy przypadek, który z pozoru wydaje si by$
naturaln% kandydatur% do zastosowania dziedziczenia. Mimo to, dokładniejsza analiza dziedzicze-
nia i implementacji klas bazowej i pochodnej spowoduje w efekcie znacz%c% modyfikacj kodu.
Przykład techniki programowania: stos
Na listingu 3.1 pokazano program, w którym zostały zdefiniowane klasy
(dosł. stos prze-
znaczony na znaki) oraz
(dosł. stos przeznaczony na liczby typu
). Przeanalizujmy i oce.-
my te klasy. Czy wida$ tu uogólnienie poj$ abstrakcyjnych? Czy dziedziczenie działa w sposób
poprawny? Czy dziedziczenie zostało wykorzystane we właciwy sposób?
LISTING 3.1.
Oryginalna wersja klas Stack, CharStack oraz IntStack
!
"#$$
%&&%'()*
"$+,$,
)*($
-)*$,
%&)*!. (/.
%&)*!.,!,.
0
Plik z chomika:
Ravel25
Inne pliki z tego folderu:
Hanna Mazur Zbigniew Mazur Projektowanie relacyjnych baz danych.pdf
(83667 KB)
Jenifer Tidwell projektowanie interfejsów. sprawdzone wzorce projektowe full.pdf
(87844 KB)
Rod Johnson, Juergen Hoeller, Alef Arendsen, Thomas Risberg, Colin Sampaleanu spring framework. profesjonalne tworzenie oprogramowania w javie full version.pdf
(16329 KB)
Donald.E.Knuth - Sztuka.programowania.(t.2).pdf
(42759 KB)
oryginal-pozycjonowanie-i-optymalizacja-stron-www-jak-si-to-robi-wydanie-iii_pozop3.pdf
(39003 KB)
Inne foldery tego chomika:
4VIP
astronomia
Download na życzenie
e-book
filmowe hity
Zgłoś jeśli
naruszono regulamin