C++. Styl programowania.pdf
(
1730 KB
)
Pobierz
C:\Andrzej\PDF\ABC nagrywania p³yt CD\1 strona.cdr
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:
radzik93
Inne pliki z tego folderu:
C++. Styl i technika zaawansowanego programowania.pdf
(1215 KB)
C++. Kruczki i fortele w programowaniu.pdf
(1032 KB)
C++. Algorytmy i struktury danych.pdf
(867 KB)
C++. Potega jezyka. Od przykladu do przykladu.pdf
(707 KB)
C++. Styl programowania.pdf
(1730 KB)
Inne foldery tego chomika:
C & C++
Pliki
Zgłoś jeśli
naruszono regulamin