SlideShare a Scribd company logo

Język C++. Koncepcje i techniki programowania

Wydawnictwo Helion, profile picture
Wydawnictwo Helion

Język C++ to najpopularniejszy obecnie język programowania. Jego podstawowe zalety -- przejrzysta składnia, niewielka ilość słów kluczowych i szeroki wachlarz możliwości -- przysporzyły mu wielu zwolenników. Na rynku dostępnych jest wiele książek o programowaniu w C++, jednak większość z nich zawiera sposoby rozwiązywania konkretnych problemów i zadań programistycznych. Niewiele książek koncentruje się na założeniach, na których opiera się programowanie w języku C++. W książce "Język C++. Koncepcje i techniki programowania" autorzy skoncentrowali się na kluczowych technikach programowania w C++. Jednak nie przedstawiają ich w formie odpowiedzi na pytania "jak to zrobić", ale "dlaczego robimy to tak, a nie inaczej". Opisują szeroki wachlarz idei i technik programowania w C++ począwszy od szczegółowych przykładów kodu, a skończywszy na zasadach i filozofii projektowania. * Tworzenie klas * Uchwyty klas * Zasady projektowania obiektowego * Szablony i iteratory * Stosowanie bibliotek * Projektowanie bibliotek * Techniki programowania Dzięki tej książce nauczysz się nie tylko przestrzegać reguł języka C++, ale także myśleć w tym języku podczas pracy nad programem. O autorach: Andrew Koenig jest członkiem działu badającego systemy oprogramowania w Shannon Laboratory firmy AT&T oraz redaktorem projektu komitetów standaryzacyjnych języka C++. [więcej...] Barbara Moo jest konsultantką z dwudziestoletnim doświadczeniem programistycznym, zarządzała projektem pierwszego kompilatora C++. [więcej...]

1 of 14
Download to read offline
1
2
3
4
5
6
7
8
9
10
11
12
13
14
IDZ DO PRZYK£ADOWY ROZDZIA£ SPIS TRE CI Jêzyk C++. Koncepcje i techniki programowania KATALOG KSI¥¯EK Autor: Andrew Koenig, Barbara Moo KATALOG ONLINE T³umaczenie: Jaros³aw Dobrzañski ISBN: 83-7361-702-7 ZAMÓW DRUKOWANY KATALOG Tytu³ orygina³u: Ruminations on C++ Format: B5, stron: 362 TWÓJ KOSZYK DODAJ DO KOSZYKA Jêzyk C++ to najpopularniejszy obecnie jêzyk programowania. Jego podstawowe zalety — przejrzysta sk³adnia, niewielka ilo æ s³ów kluczowych i szeroki wachlarz mo¿liwo ci — przysporzy³y mu wielu zwolenników. Na rynku dostêpnych jest wiele ksi¹¿ek CENNIK I INFORMACJE o programowaniu w C++, jednak wiêkszo æ z nich zawiera sposoby rozwi¹zywania konkretnych problemów i zadañ programistycznych. Niewiele ksi¹¿ek koncentruje siê ZAMÓW INFORMACJE na za³o¿eniach, na których opiera siê programowanie w jêzyku C++. O NOWO CIACH W ksi¹¿ce „Jêzyk C++. Koncepcje i techniki programowania” autorzy skoncentrowali siê na kluczowych technikach programowania w C++. Jednak nie przedstawiaj¹ ich ZAMÓW CENNIK w formie odpowiedzi na pytania „jak to zrobiæ”, ale „dlaczego robimy to tak, a nie inaczej”. Opisuj¹ szeroki wachlarz idei i technik programowania w C++ pocz¹wszy od szczegó³owych przyk³adów kodu, a skoñczywszy na zasadach i filozofii CZYTELNIA projektowania. • Tworzenie klas FRAGMENTY KSI¥¯EK ONLINE • Uchwyty klas • Zasady projektowania obiektowego • Szablony i iteratory • Stosowanie bibliotek • Projektowanie bibliotek • Techniki programowania Dziêki tej ksi¹¿ce nauczysz siê nie tylko przestrzegaæ regu³ jêzyka C++, ale tak¿e my leæ w tym jêzyku podczas pracy nad programem. Wydawnictwo Helion ul. Chopina 6 44-100 Gliwice tel. (32)230-98-63 e-mail: helion@helion.pl
Spis treści Wstęp ............................................................................................. 11 Wprowadzenie ................................................................................. 15 0.1. Podejście pierwsze.................................................................................................. 15 0.2. Jak to zrobić bez klas? ............................................................................................ 18 0.3. Dlaczego w C++ było łatwiej?................................................................................ 19 0.4. Bardziej rozbudowany przykład ............................................................................. 20 0.5. Wnioski .................................................................................................................. 20 Część I Motywacja .....................................................................23 Rozdział 1. Dlaczego używam C++? ................................................................... 25 1.1. Problem .................................................................................................................. 25 1.2. Historia i kontekst................................................................................................... 26 1.3. Automatyczna dystrybucja oprogramowania.......................................................... 27 1.4. Czas na C++ ........................................................................................................... 30 1.5. Oprogramowanie z odzysku ................................................................................... 34 1.6. Postscriptum ........................................................................................................... 35 Rozdział 2. Dlaczego pracuję nad rozwojem C++?............................................... 37 2.1. Sukces małych projektów ....................................................................................... 37 2.2. Abstrakcja............................................................................................................... 39 2.3. Maszyny powinny pracować dla ludzi.................................................................... 42 Rozdział 3. Życie w prawdziwym świecie............................................................ 43 Część II Klasy i dziedziczenie.......................................................49 Rozdział 4. Lista kontrolna dla autorów klas ...................................................... 51 Rozdział 5. Klasy surogatów .............................................................................. 61 5.1. Problem .................................................................................................................. 61 5.2. Rozwiązanie klasyczne........................................................................................... 62 5.3. Wirtualne funkcje kopiujące................................................................................... 63 5.4. Definiowanie klasy surogatu .................................................................................. 64 5.5. Podsumowanie........................................................................................................ 67 Rozdział 6. Uchwyty — część 1. ....................................................................... 69 6.1. Problem .................................................................................................................. 69 6.2. Prosta klasa............................................................................................................. 70 6.3. Przyłączanie uchwytu ............................................................................................. 72
6 Język C++. Koncepcje i techniki programowania 6.4. Dostęp do obiektu................................................................................................... 72 6.5. Prosta implementacja.............................................................................................. 73 6.6. Uchwyty z licznikami u ycia.................................................................................. 74 6.7. Kopiowanie przy zapisie......................................................................................... 76 6.8. Omówienie ............................................................................................................. 77 Rozdział 7. Uchwyty — część 2. ....................................................................... 79 7.1. Przypomnienie........................................................................................................ 80 7.2. Separowanie licznika u ycia................................................................................... 81 7.3. Abstrahowanie liczników u ycia ............................................................................ 82 7.4. Funkcje dostępowe i kopiowanie przy zapisie........................................................ 84 7.5. Omówienie ............................................................................................................. 85 Rozdział 8. Program obiektowy .......................................................................... 87 8.1. Problem .................................................................................................................. 87 8.2. Rozwiązanie obiektowe .......................................................................................... 88 8.3. Klasy uchwytów ..................................................................................................... 91 8.4. Rozwinięcie 1. — nowe operacje ........................................................................... 94 8.5. Rozwinięcie 2. — nowe typy węzłów .................................................................... 96 8.6. Refleksje................................................................................................................. 98 Rozdział 9. Analiza ćwiczenia praktycznego — część 1. ..................................... 99 9.1. Problem .................................................................................................................. 99 9.2. Projektowanie interfejsu ....................................................................................... 101 9.3. Kilka brakujących elementów .............................................................................. 103 9.4. Testowanie interfejsu............................................................................................ 104 9.5. Strategia................................................................................................................ 104 9.6. Taktyka................................................................................................................. 105 9.7. Łączenie obrazów ................................................................................................. 108 9.8. Wnioski ................................................................................................................ 111 Rozdział 10. Analiza ćwiczenia praktycznego — część 2. ................................... 113 10.1. Strategia................................................................................................................ 113 10.2. Korzystanie z mo liwości struktury ..................................................................... 125 10.3. Wnioski ................................................................................................................ 128 Rozdział 11. Kiedy nie używać funkcji wirtualnych? ............................................ 131 11.1. Argumenty „za”.................................................................................................... 131 11.2. Argumenty „przeciw”........................................................................................... 132 11.3. Szczególna rola destruktorów............................................................................... 137 11.4. Podsumowanie...................................................................................................... 139 Część III Szablony ......................................................................141 Rozdział 12. Tworzenie klasy zasobnika ............................................................. 143 12.1. Co jest w środku? ................................................................................................. 143 12.2. Co oznacza kopiowanie zasobnika? ..................................................................... 144 12.3. Jak dostać się do elementów w zasobniku? .......................................................... 147 12.4. Jak odró nić odczyt od zapisu? ............................................................................ 148 12.5. Jak poradzić sobie z rozrostem zasobnika?........................................................... 150 12.6. Jakie operacje udostępnia zasobnik? .................................................................... 151 12.7. Jakie są zało enia związane z typem elementu zasobnika? .................................. 152 12.8. Zasobniki i dziedziczenie ..................................................................................... 153 12.9. Projektowanie klasy „tablicopodobnej”................................................................ 154
Spis treści 7 Rozdział 13. Dostęp do elementów zasobnika .................................................... 161 13.1. Imitowanie wskaźnika .......................................................................................... 161 13.2. Dostęp do danych ................................................................................................. 163 13.3. Pozostałe problemy .............................................................................................. 165 13.4. Pointer wskazujący const Array ........................................................................... 169 13.5. U yteczne dodatki ................................................................................................ 170 Rozdział 14. Iteratory ........................................................................................ 175 14.1. Uzupełnianie klasy Pointer................................................................................... 175 14.2. Co to jest iterator? ................................................................................................ 178 14.3. Usuwanie elementu .............................................................................................. 179 14.4. Usuwanie zasobnika ............................................................................................. 180 14.5. Inne względy projektowe...................................................................................... 181 14.6. Podsumowanie...................................................................................................... 182 Rozdział 15. Sekwencje..................................................................................... 183 15.1. Dzieło sztuki......................................................................................................... 183 15.2. Stara, radykalna idea ............................................................................................ 185 15.3. Mo e jeszcze kilka dodatków…........................................................................... 189 15.4. Przykład zastosowania.......................................................................................... 192 15.5. Mo e jeszcze coś… .............................................................................................. 196 15.6. Do przemyślenia................................................................................................... 198 Rozdział 16. Szablony jako interfejsy ................................................................. 199 16.1. Problem ................................................................................................................ 199 16.2. Pierwszy przykład ................................................................................................ 200 16.3. Separowanie iteracji ............................................................................................. 200 16.4. Iterowanie poprzez dowolne typy......................................................................... 203 16.5. Dodawanie innych typów ..................................................................................... 204 16.6. Uogólnianie sposobu przechowywania................................................................. 204 16.7. Dowód przydatności............................................................................................. 207 16.8. Podsumowanie...................................................................................................... 208 Rozdział 17. Szablony a algorytmy ogólne .......................................................... 211 17.1. Konkretny przykład .............................................................................................. 212 17.2. Uogólnianie typu elementu................................................................................... 213 17.3. Przeło enie zliczania elementów na później......................................................... 214 17.4. Niezale ność od adresu ........................................................................................ 215 17.5. Wyszukiwanie w strukturach niebędących tablicami ........................................... 217 17.6. Podsumowanie...................................................................................................... 218 Rozdział 18. Iteratory ogólne ............................................................................. 221 18.1. Inny algorytm ....................................................................................................... 221 18.2. Kategorie i wymogi .............................................................................................. 223 18.3. Iteratory wejściowe .............................................................................................. 224 18.4. Iteratory wyjściowe .............................................................................................. 224 18.5. Iteratory postępowe .............................................................................................. 225 18.6. Iteratory dwukierunkowe...................................................................................... 226 18.7. Iteratory o dostępie swobodnym........................................................................... 226 18.8. Dziedziczenie?...................................................................................................... 227 18.9. Wydajność............................................................................................................ 228 18.10. Podsumowanie ..................................................................................................... 228 Rozdział 19. Korzystanie z iteratorów ogólnych .................................................. 231 19.1. Typy iteratorów .................................................................................................... 232 19.2. Wirtualne sekwencje ............................................................................................ 232
8 Język C++. Koncepcje i techniki programowania 19.3. Iterator strumienia wyjściowego........................................................................... 234 19.4. Iterator strumienia wejściowego........................................................................... 236 19.5. Omówienie ........................................................................................................... 239 Rozdział 20. Adaptery dla iteratorów.................................................................. 241 20.1. Przykład................................................................................................................ 241 20.2. Asymetria kierunkowa.......................................................................................... 243 20.3. Konsekwencja a asymetria ................................................................................... 244 20.4. Automatyczne odwracanie ................................................................................... 245 20.5. Omówienie ........................................................................................................... 247 Rozdział 21. Obiekty funkcji .............................................................................. 249 21.1. Przykład................................................................................................................ 249 21.2. Wskaźniki funkcji................................................................................................. 252 21.3. Obiekty funkcji..................................................................................................... 254 21.4. Szablony obiektów funkcji ................................................................................... 255 21.5. Ukrywanie typów pośrednich............................................................................... 256 21.6. Jeden typ zawiera kilka......................................................................................... 257 21.7. Implementacja ...................................................................................................... 258 21.8. Omówienie ........................................................................................................... 260 Rozdział 22. Adaptery funkcji ............................................................................ 261 22.1. Dlaczego obiekty funkcji? .................................................................................... 261 22.2. Obiekty funkcji dla operatorów wbudowanych .................................................... 262 22.3. Funkcje wią ące ................................................................................................... 263 22.4. Spojrzenie z bliska................................................................................................ 264 22.5. Dziedziczenie interfejsu ....................................................................................... 265 22.6. U ywanie klas ...................................................................................................... 266 22.7. Omówienie ........................................................................................................... 267 Część IV Biblioteki .....................................................................269 Rozdział 23. Biblioteki w bieżącym zastosowaniu ............................................... 271 23.1. Problem ................................................................................................................ 271 23.2. Istota problemu — część 1. ................................................................................. 273 23.3. Implementacja — część 1. ................................................................................... 273 23.4. Istota problemu — część 2. ................................................................................. 276 23.5. Implementacja — część 2. ................................................................................... 276 23.6. Omówienie ........................................................................................................... 278 Rozdział 24. Obiektowa lekcja projektowania interfejsu biblioteki....................... 281 24.1. Komplikacje ......................................................................................................... 282 24.2. Poprawianie interfejsu .......................................................................................... 283 24.3. Szczegółowe rozwa ania...................................................................................... 285 24.4. Pisanie kodu ......................................................................................................... 286 24.5. Wnioski ................................................................................................................ 288 Rozdział 25. Projektowanie bibliotek jako budowanie języka............................... 289 25.1. Ciągi znakowe ...................................................................................................... 289 25.2. Wyczerpanie dostępnej pamięci ........................................................................... 290 25.3. Kopiowanie .......................................................................................................... 293 25.4. Ukrywanie implementacji..................................................................................... 296 25.5. Konstruktor domyślny .......................................................................................... 298 25.6. Inne operacje ........................................................................................................ 299 25.7. Podciągi................................................................................................................ 301 25.8. Wnioski ................................................................................................................ 302
Spis treści 9 Rozdział 26. Projektowanie języka jako budowanie bibliotek............................... 303 26.1. Abstrakcyjne typy danych .................................................................................... 303 26.2. Biblioteki i abstrakcyjne typy danych................................................................... 305 26.3. Rezerwacja pamięci.............................................................................................. 308 26.4. Przyporządkowywanie i inicjalizacja składowych klas ........................................ 309 26.5. Obsługa wyjątków ................................................................................................ 311 26.6. Podsumowanie...................................................................................................... 312 Część V Techniki.......................................................................313 Rozdział 27. Klasy, które się śledzą ................................................................... 315 27.1. Projektowanie klasy śledzącej .............................................................................. 315 27.2. Tworzenie martwego kodu ................................................................................... 318 27.3. Generowanie wyników inspekcji dla obiektów .................................................... 319 27.4. Weryfikowanie zachowania zasobnika................................................................. 321 27.5. Podsumowanie...................................................................................................... 325 Rozdział 28. Grupowy przydział pamięci dla obiektów ......................................... 327 28.1. Problem ................................................................................................................ 327 28.2. Projektowanie rozwiązania................................................................................... 327 28.3. Implementacja ...................................................................................................... 330 28.4. Dziedziczenie ....................................................................................................... 332 28.5. Podsumowanie...................................................................................................... 333 Rozdział 29. Aplikatory, manipulatory i obiekty funkcji ....................................... 335 29.1. Problem ................................................................................................................ 336 29.2. Rozwiązanie ......................................................................................................... 338 29.3. Inne rozwiązanie................................................................................................... 338 29.4. Dodatkowe argumenty.......................................................................................... 340 29.5. Przykład................................................................................................................ 341 29.6. Formy skrócone.................................................................................................... 343 29.7. Przemyślenia ........................................................................................................ 344 29.8. Uwagi historyczne, źródła i podziękowania ......................................................... 345 Rozdział 30. Uniezależnianie bibliotek aplikacji od wejść i wyjść......................... 347 30.1. Problem ................................................................................................................ 347 30.2. Rozwiązanie 1. — spryt i metoda siłowa.............................................................. 348 30.3. Rozwiązanie 2. — abstrakcyjne wyjście .............................................................. 349 30.4. Rozwiązanie 3. — spryt bez metody siłowej........................................................ 351 30.5. Uwagi ................................................................................................................... 354 Część VI Podsumowanie.............................................................355 Rozdział 31. Przez złożoność do prostoty............................................................ 357 31.1. Świat jest zło ony................................................................................................. 357 31.2. Zło oność staje się ukryta..................................................................................... 358 31.3. Komputery mają to samo...................................................................................... 359 31.4. Komputery rozwiązują prawdziwe problemy ....................................................... 361 31.5. Biblioteki klas i semantyka języka ....................................................................... 362 31.6. Ułatwianie jest trudne........................................................................................... 364 31.7. Abstrakcja a interfejs ............................................................................................ 365 31.8. Konserwacja zło oności ....................................................................................... 366
10 Język C++. Koncepcje i techniki programowania Rozdział 32. „Witaj świecie” i co dalej?............................................................. 367 32.1. Znajdź w pobli u eksperta.................................................................................... 367 32.2. Wybierz narzędzie i opanuj je .............................................................................. 368 32.3. Niektóre elementy C są wa ne….......................................................................... 368 32.4. …inne niekoniecznie ............................................................................................ 370 32.5. Wyznacz sobie szereg problemów do rozwiązania............................................... 371 32.6. Konkluzja ............................................................................................................. 374 Dodatki .......................................................................................377 Skorowidz...................................................................................... 379
Rozdział 5. Klasy surogatów Jak zaprojektować zasobnik C++, który potencjalnie mo e zawierać obiekty ró nych, ale powiązanych ze sobą typów? Ju samo przechowywanie obiektów w zasobniku jest trudne, poniewa zasobniki generalnie przechowują obiekty jednego typu. Prze- chowywanie wskaźników obiektów, mimo e pozwala na obsługę ró nych typów z po- mocą dziedziczenia, wią e się z koniecznością przydziału dodatkowej pamięci. Przyjrzymy się tutaj jednemu ze sposobów rozwiązania tego problemu, polegającemu na zdefiniowaniu obiektów zwanych surogatami, które zachowują się niemal tak, jak obiekty, które reprezentują, ale pozwalają na sprowadzenie całej hierarchii typów do jednego tylko typu. Surogaty to najprostsza postać klas uchwytów, opisanych we wstępie do tej części ksią ki. W kolejnych rozdziałach rozwinięte zostaną przedsta- wione tu ogólnie zagadnienia. 5.1. Problem Przypuśćmy, e mamy hierarchię klas, która reprezentuje ró ne rodzaje środków transportu: ENCUU 8GJKENG ] RWDNKE XKTVWCN FQWDNG YGKIJV EQPUV XKTVWCN XQKF UVCTV _ ENCUU 4QCF8GJKENG RWDNKE 8GJKENG ]
_ ENCUU #WVQOQDKNG RWDNKE 4QCF8GJKENG ]
_ ENCUU #KTETCHV RWDNKE 8GJKENG ]
_ ENCUU *GNKEQRVGT RWDNKE #KTETCHV ]
_ i tak dalej. Wszystkie środki transportu (8GJKENG) mają pewne wspólne właściwości, które opisują składowe klasy 8GJKENG. Jednak niektóre z nich mają właściwości, których nie posiadają inne. Na przykład, tylko samolot (#KTETCHV) mo e latać, a tylko helikopter (*GNKEQRVGT) mo e wykonywać lot wiszący.
62 Część II ♦ Klasy i dziedziczenie Załó my teraz, e chcemy śledzić zbiór ró nego rodzaju środków transportu (8GJKENG). W praktyce zastosowalibyśmy zapewne pewien rodzaj klasy zasobnika. Jednak, dla uproszczenia przykładu, zadowolimy się tablicą. Spróbujmy więc: 8GJKENG RCTMKPIANQV=? Nie udało się. Dlaczego? Na pozór powodem jest to, e 8GJKENG jest abstrakcyjną klasą bazową — w końcu jej funkcje składowe YGKIJV i UVCTV to funkcje czysto abstrakcyjne. Poprzez dopisanie w deklaracjach, funkcje te pozostały jawnie niezdefiniowane. Wynika z tego, e nie mogą istnieć obiekty klasy 8GJKENG, a jedynie obiekty klas potomnych klasie 8GJKENG. Je eli nie mogą istnieć obiekty 8GJKENG, niemo liwe jest równie stworzenie tablicy takich obiektów. Istnieje te głębsza przyczyna naszego niepowodzenia, którą mo na odkryć zadając sobie pytanie: co stałoby się, gdyby istnienie obiektów klasy 8GJKENG było mimo wszys- tko mo liwe. Powiedzmy, e pozbyliśmy się wszystkich czysto wirtualnych funkcji z klasy 8GJKENG i napisaliśmy: #WVQOQDKNG Z
RCTMKPIANQV=PWOAXGJKENGU ? Z Przyporządkowanie Z elementowi tablicy RCTMKPIANQV spowoduje konwersję Z na typ 8GJKENG drogą odrzucenia wszystkich składowych, które nie stanowią części samej klasy 8GJKENG. Dopiero potem operacja przyporządkowania skopiuje ten (okrojony) obiekt do tablicy RCTMKPIANQV. W efekcie zdefiniowaliśmy RCTMKPIANQV jako zbiór obiektów 8GJKENG, a nie zbiór obiek- tów klas potomnych klasie 8GJKENG. 5.2. Rozwiązanie klasyczne Normalnym sposobem na osiągnięcie elastyczności w tego typu sytuacjach jest wpro- wadzenie pośredniości. Najprostsza, mo liwa tu do zastosowania forma pośredniości sprowadza się do przechowywania wskaźników, zamiast samych obiektów: 8GJKENG

More Related Content

PDF
C++. Strategie i taktyki. Vademecum profesjonalisty
Wydawnictwo Helion
 
PDF
C++. Styl i technika zaawansowanego programowania
Wydawnictwo Helion
 
PDF
Język C++. Gotowe rozwiązania dla programistów
Wydawnictwo Helion
 
PDF
C++ dla programistów gier. Wydanie II
Wydawnictwo Helion
 
PDF
Wyjątkowy język C++. 40 nowych łamigłówek, zadań programistycznych i rozwiązań
Wydawnictwo Helion
 
PDF
Programowanie w języku C. FAQ
Wydawnictwo Helion
 
PDF
C++ bez obaw
Wydawnictwo Helion
 
PDF
C++. Inżynieria programowania
Wydawnictwo Helion
 
C++. Strategie i taktyki. Vademecum profesjonalisty
Wydawnictwo Helion
 
C++. Styl i technika zaawansowanego programowania
Wydawnictwo Helion
 
Język C++. Gotowe rozwiązania dla programistów
Wydawnictwo Helion
 
C++ dla programistów gier. Wydanie II
Wydawnictwo Helion
 
Wyjątkowy język C++. 40 nowych łamigłówek, zadań programistycznych i rozwiązań
Wydawnictwo Helion
 
Programowanie w języku C. FAQ
Wydawnictwo Helion
 
C++ bez obaw
Wydawnictwo Helion
 
C++. Inżynieria programowania
Wydawnictwo Helion
 

What's hot (20)

PDF
C++. 50 efektywnych sposobów na udoskonalenie Twoich programów
Wydawnictwo Helion
 
PDF
Thinking in C++. Edycja polska. Tom 2
Wydawnictwo Helion
 
PDF
Uczta programistów
Wydawnictwo Helion
 
PDF
Język C++. Standardy kodowania. 101 zasad, wytycznych i zalecanych praktyk
Wydawnictwo Helion
 
PDF
C++. Zaawansowane programowanie
Wydawnictwo Helion
 
PDF
C++. Programowanie zorientowane obiektowo. Vademecum profesjonalisty
Wydawnictwo Helion
 
PDF
eXtreme programming
Wydawnictwo Helion
 
PDF
Język C. Wskaźniki. Vademecum profesjonalisty
Wydawnictwo Helion
 
PDF
C++Builder 6. Ćwiczenia
Wydawnictwo Helion
 
PDF
Programowanie. Od podstaw
Wydawnictwo Helion
 
PDF
C++. Kruczki i fortele w programowaniu
Wydawnictwo Helion
 
PDF
Wzorce projektowe. Analiza kodu sposobem na ich poznanie
Wydawnictwo Helion
 
PDF
Prolog. Programowanie
Wydawnictwo Helion
 
PDF
CorelDRAW 11. Vademecum profesjonalisty. Tom 1
Wydawnictwo Helion
 
PDF
Język C. Programowanie
Wydawnictwo Helion
 
PDF
Visual Basic .NET. Wzorce projektowe
Wydawnictwo Helion
 
PDF
C#. Ćwiczenia
Wydawnictwo Helion
 
PDF
Aplikacje w Visual C++ 2005. Przykłady
Wydawnictwo Helion
 
PDF
Java. Tworzenie aplikacji sieciowych za pomocą Springa, Hibernate i Eclipse
Wydawnictwo Helion
 
PDF
Praktyczny kurs Java
Wydawnictwo Helion
 
C++. 50 efektywnych sposobów na udoskonalenie Twoich programów
Wydawnictwo Helion
 
Thinking in C++. Edycja polska. Tom 2
Wydawnictwo Helion
 
Uczta programistów
Wydawnictwo Helion
 
Język C++. Standardy kodowania. 101 zasad, wytycznych i zalecanych praktyk
Wydawnictwo Helion
 
C++. Zaawansowane programowanie
Wydawnictwo Helion
 
C++. Programowanie zorientowane obiektowo. Vademecum profesjonalisty
Wydawnictwo Helion
 
eXtreme programming
Wydawnictwo Helion
 
Język C. Wskaźniki. Vademecum profesjonalisty
Wydawnictwo Helion
 
C++Builder 6. Ćwiczenia
Wydawnictwo Helion
 
Programowanie. Od podstaw
Wydawnictwo Helion
 
C++. Kruczki i fortele w programowaniu
Wydawnictwo Helion
 
Wzorce projektowe. Analiza kodu sposobem na ich poznanie
Wydawnictwo Helion
 
Prolog. Programowanie
Wydawnictwo Helion
 
CorelDRAW 11. Vademecum profesjonalisty. Tom 1
Wydawnictwo Helion
 
Język C. Programowanie
Wydawnictwo Helion
 
Visual Basic .NET. Wzorce projektowe
Wydawnictwo Helion
 
C#. Ćwiczenia
Wydawnictwo Helion
 
Aplikacje w Visual C++ 2005. Przykłady
Wydawnictwo Helion
 
Java. Tworzenie aplikacji sieciowych za pomocą Springa, Hibernate i Eclipse
Wydawnictwo Helion
 
Praktyczny kurs Java
Wydawnictwo Helion
 
Ad

Viewers also liked (10)

PDF
PHP5. Księga eksperta
Wydawnictwo Helion
 
PDF
CVS bez tajemnic
Wydawnictwo Helion
 
PDF
Po prostu Nero 7
Wydawnictwo Helion
 
PDF
Projektowanie zorientowane obiektowo. Wzorce projektowe. Wydanie II
Wydawnictwo Helion
 
PDF
Architektura systemów zarządzania przedsiębiorstwem. Wzorce projektowe
Wydawnictwo Helion
 
PDF
Jak działa Linux
Wydawnictwo Helion
 
PDF
PHP5. Zaawansowane programowanie
Wydawnictwo Helion
 
PDF
Windows XP Pro. Nieoficjalny podręcznik
Wydawnictwo Helion
 
PDF
Alchemia manipulacji
Wydawnictwo Helion
 
PDF
Excel. Indywidualne szkolenie
Wydawnictwo Helion
 
PHP5. Księga eksperta
Wydawnictwo Helion
 
CVS bez tajemnic
Wydawnictwo Helion
 
Po prostu Nero 7
Wydawnictwo Helion
 
Projektowanie zorientowane obiektowo. Wzorce projektowe. Wydanie II
Wydawnictwo Helion
 
Architektura systemów zarządzania przedsiębiorstwem. Wzorce projektowe
Wydawnictwo Helion
 
Jak działa Linux
Wydawnictwo Helion
 
PHP5. Zaawansowane programowanie
Wydawnictwo Helion
 
Windows XP Pro. Nieoficjalny podręcznik
Wydawnictwo Helion
 
Alchemia manipulacji
Wydawnictwo Helion
 
Excel. Indywidualne szkolenie
Wydawnictwo Helion
 
Ad

Similar to Język C++. Koncepcje i techniki programowania (20)

PDF
C++. Potęga języka. Od przykładu do przykładu
Wydawnictwo Helion
 
PDF
C++. Sztuka programowania
Wydawnictwo Helion
 
PDF
Język C++. Szkoła programowania. Wydanie V
Wydawnictwo Helion
 
PDF
C++. Styl programowania
Wydawnictwo Helion
 
PDF
C++Builder. Kompendium programisty
Wydawnictwo Helion
 
PDF
C++BuilderX. Ćwiczenia
Wydawnictwo Helion
 
PDF
C++Builder Borland Developer Studio 2006. Kompendium programisty
Wydawnictwo Helion
 
PDF
C++Builder i Turbo C++. Podstawy
Wydawnictwo Helion
 
PDF
C++. Algorytmy i struktury danych
Wydawnictwo Helion
 
PDF
Czytanie kodu. Punkt widzenia twórców oprogramowania open source
Wydawnictwo Helion
 
PDF
Programowanie w języku C. Szybki start
Wydawnictwo Helion
 
PDF
C++ Builder 6. Vademecum profesjonalisty
Wydawnictwo Helion
 
PDF
Efektywne programowanie w języku Java
Wydawnictwo Helion
 
PDF
C++Builder 6 i bazy danych
Wydawnictwo Helion
 
PDF
Struktury danych i techniki obiektowe na przykładzie Javy 5.0
Wydawnictwo Helion
 
PDF
C++. Leksykon kieszonkowy
Wydawnictwo Helion
 
PDF
Visual C# .NET. Encyklopedia
Wydawnictwo Helion
 
PDF
C++Builder 2006. Ćwiczenia praktyczne
Wydawnictwo Helion
 
PDF
Programowanie zorientowane obiektowo
Wydawnictwo Helion
 
PDF
Delphi. Szybki start
Wydawnictwo Helion
 
C++. Potęga języka. Od przykładu do przykładu
Wydawnictwo Helion
 
C++. Sztuka programowania
Wydawnictwo Helion
 
Język C++. Szkoła programowania. Wydanie V
Wydawnictwo Helion
 
C++. Styl programowania
Wydawnictwo Helion
 
C++Builder. Kompendium programisty
Wydawnictwo Helion
 
C++BuilderX. Ćwiczenia
Wydawnictwo Helion
 
C++Builder Borland Developer Studio 2006. Kompendium programisty
Wydawnictwo Helion
 
C++Builder i Turbo C++. Podstawy
Wydawnictwo Helion
 
C++. Algorytmy i struktury danych
Wydawnictwo Helion
 
Czytanie kodu. Punkt widzenia twórców oprogramowania open source
Wydawnictwo Helion
 
Programowanie w języku C. Szybki start
Wydawnictwo Helion
 
C++ Builder 6. Vademecum profesjonalisty
Wydawnictwo Helion
 
Efektywne programowanie w języku Java
Wydawnictwo Helion
 
C++Builder 6 i bazy danych
Wydawnictwo Helion
 
Struktury danych i techniki obiektowe na przykładzie Javy 5.0
Wydawnictwo Helion
 
C++. Leksykon kieszonkowy
Wydawnictwo Helion
 
Visual C# .NET. Encyklopedia
Wydawnictwo Helion
 
C++Builder 2006. Ćwiczenia praktyczne
Wydawnictwo Helion
 
Programowanie zorientowane obiektowo
Wydawnictwo Helion
 
Delphi. Szybki start
Wydawnictwo Helion
 

More from Wydawnictwo Helion (20)

PDF
Tworzenie filmów w Windows XP. Projekty
Wydawnictwo Helion
 
PDF
Blog, więcej niż internetowy pamiętnik
Wydawnictwo Helion
 
PDF
Access w biurze i nie tylko
Wydawnictwo Helion
 
PDF
Pozycjonowanie i optymalizacja stron WWW. Ćwiczenia praktyczne
Wydawnictwo Helion
 
PDF
E-wizerunek. Internet jako narzędzie kreowania image'u w biznesie
Wydawnictwo Helion
 
PDF
Microsoft Visual C++ 2008. Tworzenie aplikacji dla Windows
Wydawnictwo Helion
 
PDF
Co potrafi Twój iPhone? Podręcznik użytkownika. Wydanie II
Wydawnictwo Helion
 
PDF
Makrofotografia. Magia szczegółu
Wydawnictwo Helion
 
PDF
Windows PowerShell. Podstawy
Wydawnictwo Helion
 
PDF
Java. Efektywne programowanie. Wydanie II
Wydawnictwo Helion
 
PDF
JavaScript. Pierwsze starcie
Wydawnictwo Helion
 
PDF
Ajax, JavaScript i PHP. Intensywny trening
Wydawnictwo Helion
 
PDF
PowerPoint 2007 PL. Seria praktyk
Wydawnictwo Helion
 
PDF
Excel 2007 PL. Seria praktyk
Wydawnictwo Helion
 
PDF
Access 2007 PL. Seria praktyk
Wydawnictwo Helion
 
PDF
Word 2007 PL. Seria praktyk
Wydawnictwo Helion
 
PDF
Serwisy społecznościowe. Budowa, administracja i moderacja
Wydawnictwo Helion
 
PDF
AutoCAD 2008 i 2008 PL
Wydawnictwo Helion
 
PDF
Bazy danych. Pierwsze starcie
Wydawnictwo Helion
 
PDF
Inventor. Pierwsze kroki
Wydawnictwo Helion
 
Tworzenie filmów w Windows XP. Projekty
Wydawnictwo Helion
 
Blog, więcej niż internetowy pamiętnik
Wydawnictwo Helion
 
Access w biurze i nie tylko
Wydawnictwo Helion
 
Pozycjonowanie i optymalizacja stron WWW. Ćwiczenia praktyczne
Wydawnictwo Helion
 
E-wizerunek. Internet jako narzędzie kreowania image'u w biznesie
Wydawnictwo Helion
 
Microsoft Visual C++ 2008. Tworzenie aplikacji dla Windows
Wydawnictwo Helion
 
Co potrafi Twój iPhone? Podręcznik użytkownika. Wydanie II
Wydawnictwo Helion
 
Makrofotografia. Magia szczegółu
Wydawnictwo Helion
 
Windows PowerShell. Podstawy
Wydawnictwo Helion
 
Java. Efektywne programowanie. Wydanie II
Wydawnictwo Helion
 
JavaScript. Pierwsze starcie
Wydawnictwo Helion
 
Ajax, JavaScript i PHP. Intensywny trening
Wydawnictwo Helion
 
PowerPoint 2007 PL. Seria praktyk
Wydawnictwo Helion
 
Excel 2007 PL. Seria praktyk
Wydawnictwo Helion
 
Access 2007 PL. Seria praktyk
Wydawnictwo Helion
 
Word 2007 PL. Seria praktyk
Wydawnictwo Helion
 
Serwisy społecznościowe. Budowa, administracja i moderacja
Wydawnictwo Helion
 
AutoCAD 2008 i 2008 PL
Wydawnictwo Helion
 
Bazy danych. Pierwsze starcie
Wydawnictwo Helion
 
Inventor. Pierwsze kroki
Wydawnictwo Helion
 

Język C++. Koncepcje i techniki programowania

  • 1. IDZ DO PRZYK£ADOWY ROZDZIA£ SPIS TRE CI Jêzyk C++. Koncepcje i techniki programowania KATALOG KSI¥¯EK Autor: Andrew Koenig, Barbara Moo KATALOG ONLINE T³umaczenie: Jaros³aw Dobrzañski ISBN: 83-7361-702-7 ZAMÓW DRUKOWANY KATALOG Tytu³ orygina³u: Ruminations on C++ Format: B5, stron: 362 TWÓJ KOSZYK DODAJ DO KOSZYKA Jêzyk C++ to najpopularniejszy obecnie jêzyk programowania. Jego podstawowe zalety — przejrzysta sk³adnia, niewielka ilo æ s³ów kluczowych i szeroki wachlarz mo¿liwo ci — przysporzy³y mu wielu zwolenników. Na rynku dostêpnych jest wiele ksi¹¿ek CENNIK I INFORMACJE o programowaniu w C++, jednak wiêkszo æ z nich zawiera sposoby rozwi¹zywania konkretnych problemów i zadañ programistycznych. Niewiele ksi¹¿ek koncentruje siê ZAMÓW INFORMACJE na za³o¿eniach, na których opiera siê programowanie w jêzyku C++. O NOWO CIACH W ksi¹¿ce „Jêzyk C++. Koncepcje i techniki programowania” autorzy skoncentrowali siê na kluczowych technikach programowania w C++. Jednak nie przedstawiaj¹ ich ZAMÓW CENNIK w formie odpowiedzi na pytania „jak to zrobiæ”, ale „dlaczego robimy to tak, a nie inaczej”. Opisuj¹ szeroki wachlarz idei i technik programowania w C++ pocz¹wszy od szczegó³owych przyk³adów kodu, a skoñczywszy na zasadach i filozofii CZYTELNIA projektowania. • Tworzenie klas FRAGMENTY KSI¥¯EK ONLINE • Uchwyty klas • Zasady projektowania obiektowego • Szablony i iteratory • Stosowanie bibliotek • Projektowanie bibliotek • Techniki programowania Dziêki tej ksi¹¿ce nauczysz siê nie tylko przestrzegaæ regu³ jêzyka C++, ale tak¿e my leæ w tym jêzyku podczas pracy nad programem. Wydawnictwo Helion ul. Chopina 6 44-100 Gliwice tel. (32)230-98-63 e-mail: helion@helion.pl
  • 2. Spis treści Wstęp ............................................................................................. 11 Wprowadzenie ................................................................................. 15 0.1. Podejście pierwsze.................................................................................................. 15 0.2. Jak to zrobić bez klas? ............................................................................................ 18 0.3. Dlaczego w C++ było łatwiej?................................................................................ 19 0.4. Bardziej rozbudowany przykład ............................................................................. 20 0.5. Wnioski .................................................................................................................. 20 Część I Motywacja .....................................................................23 Rozdział 1. Dlaczego używam C++? ................................................................... 25 1.1. Problem .................................................................................................................. 25 1.2. Historia i kontekst................................................................................................... 26 1.3. Automatyczna dystrybucja oprogramowania.......................................................... 27 1.4. Czas na C++ ........................................................................................................... 30 1.5. Oprogramowanie z odzysku ................................................................................... 34 1.6. Postscriptum ........................................................................................................... 35 Rozdział 2. Dlaczego pracuję nad rozwojem C++?............................................... 37 2.1. Sukces małych projektów ....................................................................................... 37 2.2. Abstrakcja............................................................................................................... 39 2.3. Maszyny powinny pracować dla ludzi.................................................................... 42 Rozdział 3. Życie w prawdziwym świecie............................................................ 43 Część II Klasy i dziedziczenie.......................................................49 Rozdział 4. Lista kontrolna dla autorów klas ...................................................... 51 Rozdział 5. Klasy surogatów .............................................................................. 61 5.1. Problem .................................................................................................................. 61 5.2. Rozwiązanie klasyczne........................................................................................... 62 5.3. Wirtualne funkcje kopiujące................................................................................... 63 5.4. Definiowanie klasy surogatu .................................................................................. 64 5.5. Podsumowanie........................................................................................................ 67 Rozdział 6. Uchwyty — część 1. ....................................................................... 69 6.1. Problem .................................................................................................................. 69 6.2. Prosta klasa............................................................................................................. 70 6.3. Przyłączanie uchwytu ............................................................................................. 72
  • 3. 6 Język C++. Koncepcje i techniki programowania 6.4. Dostęp do obiektu................................................................................................... 72 6.5. Prosta implementacja.............................................................................................. 73 6.6. Uchwyty z licznikami u ycia.................................................................................. 74 6.7. Kopiowanie przy zapisie......................................................................................... 76 6.8. Omówienie ............................................................................................................. 77 Rozdział 7. Uchwyty — część 2. ....................................................................... 79 7.1. Przypomnienie........................................................................................................ 80 7.2. Separowanie licznika u ycia................................................................................... 81 7.3. Abstrahowanie liczników u ycia ............................................................................ 82 7.4. Funkcje dostępowe i kopiowanie przy zapisie........................................................ 84 7.5. Omówienie ............................................................................................................. 85 Rozdział 8. Program obiektowy .......................................................................... 87 8.1. Problem .................................................................................................................. 87 8.2. Rozwiązanie obiektowe .......................................................................................... 88 8.3. Klasy uchwytów ..................................................................................................... 91 8.4. Rozwinięcie 1. — nowe operacje ........................................................................... 94 8.5. Rozwinięcie 2. — nowe typy węzłów .................................................................... 96 8.6. Refleksje................................................................................................................. 98 Rozdział 9. Analiza ćwiczenia praktycznego — część 1. ..................................... 99 9.1. Problem .................................................................................................................. 99 9.2. Projektowanie interfejsu ....................................................................................... 101 9.3. Kilka brakujących elementów .............................................................................. 103 9.4. Testowanie interfejsu............................................................................................ 104 9.5. Strategia................................................................................................................ 104 9.6. Taktyka................................................................................................................. 105 9.7. Łączenie obrazów ................................................................................................. 108 9.8. Wnioski ................................................................................................................ 111 Rozdział 10. Analiza ćwiczenia praktycznego — część 2. ................................... 113 10.1. Strategia................................................................................................................ 113 10.2. Korzystanie z mo liwości struktury ..................................................................... 125 10.3. Wnioski ................................................................................................................ 128 Rozdział 11. Kiedy nie używać funkcji wirtualnych? ............................................ 131 11.1. Argumenty „za”.................................................................................................... 131 11.2. Argumenty „przeciw”........................................................................................... 132 11.3. Szczególna rola destruktorów............................................................................... 137 11.4. Podsumowanie...................................................................................................... 139 Część III Szablony ......................................................................141 Rozdział 12. Tworzenie klasy zasobnika ............................................................. 143 12.1. Co jest w środku? ................................................................................................. 143 12.2. Co oznacza kopiowanie zasobnika? ..................................................................... 144 12.3. Jak dostać się do elementów w zasobniku? .......................................................... 147 12.4. Jak odró nić odczyt od zapisu? ............................................................................ 148 12.5. Jak poradzić sobie z rozrostem zasobnika?........................................................... 150 12.6. Jakie operacje udostępnia zasobnik? .................................................................... 151 12.7. Jakie są zało enia związane z typem elementu zasobnika? .................................. 152 12.8. Zasobniki i dziedziczenie ..................................................................................... 153 12.9. Projektowanie klasy „tablicopodobnej”................................................................ 154
  • 4. Spis treści 7 Rozdział 13. Dostęp do elementów zasobnika .................................................... 161 13.1. Imitowanie wskaźnika .......................................................................................... 161 13.2. Dostęp do danych ................................................................................................. 163 13.3. Pozostałe problemy .............................................................................................. 165 13.4. Pointer wskazujący const Array ........................................................................... 169 13.5. U yteczne dodatki ................................................................................................ 170 Rozdział 14. Iteratory ........................................................................................ 175 14.1. Uzupełnianie klasy Pointer................................................................................... 175 14.2. Co to jest iterator? ................................................................................................ 178 14.3. Usuwanie elementu .............................................................................................. 179 14.4. Usuwanie zasobnika ............................................................................................. 180 14.5. Inne względy projektowe...................................................................................... 181 14.6. Podsumowanie...................................................................................................... 182 Rozdział 15. Sekwencje..................................................................................... 183 15.1. Dzieło sztuki......................................................................................................... 183 15.2. Stara, radykalna idea ............................................................................................ 185 15.3. Mo e jeszcze kilka dodatków…........................................................................... 189 15.4. Przykład zastosowania.......................................................................................... 192 15.5. Mo e jeszcze coś… .............................................................................................. 196 15.6. Do przemyślenia................................................................................................... 198 Rozdział 16. Szablony jako interfejsy ................................................................. 199 16.1. Problem ................................................................................................................ 199 16.2. Pierwszy przykład ................................................................................................ 200 16.3. Separowanie iteracji ............................................................................................. 200 16.4. Iterowanie poprzez dowolne typy......................................................................... 203 16.5. Dodawanie innych typów ..................................................................................... 204 16.6. Uogólnianie sposobu przechowywania................................................................. 204 16.7. Dowód przydatności............................................................................................. 207 16.8. Podsumowanie...................................................................................................... 208 Rozdział 17. Szablony a algorytmy ogólne .......................................................... 211 17.1. Konkretny przykład .............................................................................................. 212 17.2. Uogólnianie typu elementu................................................................................... 213 17.3. Przeło enie zliczania elementów na później......................................................... 214 17.4. Niezale ność od adresu ........................................................................................ 215 17.5. Wyszukiwanie w strukturach niebędących tablicami ........................................... 217 17.6. Podsumowanie...................................................................................................... 218 Rozdział 18. Iteratory ogólne ............................................................................. 221 18.1. Inny algorytm ....................................................................................................... 221 18.2. Kategorie i wymogi .............................................................................................. 223 18.3. Iteratory wejściowe .............................................................................................. 224 18.4. Iteratory wyjściowe .............................................................................................. 224 18.5. Iteratory postępowe .............................................................................................. 225 18.6. Iteratory dwukierunkowe...................................................................................... 226 18.7. Iteratory o dostępie swobodnym........................................................................... 226 18.8. Dziedziczenie?...................................................................................................... 227 18.9. Wydajność............................................................................................................ 228 18.10. Podsumowanie ..................................................................................................... 228 Rozdział 19. Korzystanie z iteratorów ogólnych .................................................. 231 19.1. Typy iteratorów .................................................................................................... 232 19.2. Wirtualne sekwencje ............................................................................................ 232
  • 5. 8 Język C++. Koncepcje i techniki programowania 19.3. Iterator strumienia wyjściowego........................................................................... 234 19.4. Iterator strumienia wejściowego........................................................................... 236 19.5. Omówienie ........................................................................................................... 239 Rozdział 20. Adaptery dla iteratorów.................................................................. 241 20.1. Przykład................................................................................................................ 241 20.2. Asymetria kierunkowa.......................................................................................... 243 20.3. Konsekwencja a asymetria ................................................................................... 244 20.4. Automatyczne odwracanie ................................................................................... 245 20.5. Omówienie ........................................................................................................... 247 Rozdział 21. Obiekty funkcji .............................................................................. 249 21.1. Przykład................................................................................................................ 249 21.2. Wskaźniki funkcji................................................................................................. 252 21.3. Obiekty funkcji..................................................................................................... 254 21.4. Szablony obiektów funkcji ................................................................................... 255 21.5. Ukrywanie typów pośrednich............................................................................... 256 21.6. Jeden typ zawiera kilka......................................................................................... 257 21.7. Implementacja ...................................................................................................... 258 21.8. Omówienie ........................................................................................................... 260 Rozdział 22. Adaptery funkcji ............................................................................ 261 22.1. Dlaczego obiekty funkcji? .................................................................................... 261 22.2. Obiekty funkcji dla operatorów wbudowanych .................................................... 262 22.3. Funkcje wią ące ................................................................................................... 263 22.4. Spojrzenie z bliska................................................................................................ 264 22.5. Dziedziczenie interfejsu ....................................................................................... 265 22.6. U ywanie klas ...................................................................................................... 266 22.7. Omówienie ........................................................................................................... 267 Część IV Biblioteki .....................................................................269 Rozdział 23. Biblioteki w bieżącym zastosowaniu ............................................... 271 23.1. Problem ................................................................................................................ 271 23.2. Istota problemu — część 1. ................................................................................. 273 23.3. Implementacja — część 1. ................................................................................... 273 23.4. Istota problemu — część 2. ................................................................................. 276 23.5. Implementacja — część 2. ................................................................................... 276 23.6. Omówienie ........................................................................................................... 278 Rozdział 24. Obiektowa lekcja projektowania interfejsu biblioteki....................... 281 24.1. Komplikacje ......................................................................................................... 282 24.2. Poprawianie interfejsu .......................................................................................... 283 24.3. Szczegółowe rozwa ania...................................................................................... 285 24.4. Pisanie kodu ......................................................................................................... 286 24.5. Wnioski ................................................................................................................ 288 Rozdział 25. Projektowanie bibliotek jako budowanie języka............................... 289 25.1. Ciągi znakowe ...................................................................................................... 289 25.2. Wyczerpanie dostępnej pamięci ........................................................................... 290 25.3. Kopiowanie .......................................................................................................... 293 25.4. Ukrywanie implementacji..................................................................................... 296 25.5. Konstruktor domyślny .......................................................................................... 298 25.6. Inne operacje ........................................................................................................ 299 25.7. Podciągi................................................................................................................ 301 25.8. Wnioski ................................................................................................................ 302
  • 6. Spis treści 9 Rozdział 26. Projektowanie języka jako budowanie bibliotek............................... 303 26.1. Abstrakcyjne typy danych .................................................................................... 303 26.2. Biblioteki i abstrakcyjne typy danych................................................................... 305 26.3. Rezerwacja pamięci.............................................................................................. 308 26.4. Przyporządkowywanie i inicjalizacja składowych klas ........................................ 309 26.5. Obsługa wyjątków ................................................................................................ 311 26.6. Podsumowanie...................................................................................................... 312 Część V Techniki.......................................................................313 Rozdział 27. Klasy, które się śledzą ................................................................... 315 27.1. Projektowanie klasy śledzącej .............................................................................. 315 27.2. Tworzenie martwego kodu ................................................................................... 318 27.3. Generowanie wyników inspekcji dla obiektów .................................................... 319 27.4. Weryfikowanie zachowania zasobnika................................................................. 321 27.5. Podsumowanie...................................................................................................... 325 Rozdział 28. Grupowy przydział pamięci dla obiektów ......................................... 327 28.1. Problem ................................................................................................................ 327 28.2. Projektowanie rozwiązania................................................................................... 327 28.3. Implementacja ...................................................................................................... 330 28.4. Dziedziczenie ....................................................................................................... 332 28.5. Podsumowanie...................................................................................................... 333 Rozdział 29. Aplikatory, manipulatory i obiekty funkcji ....................................... 335 29.1. Problem ................................................................................................................ 336 29.2. Rozwiązanie ......................................................................................................... 338 29.3. Inne rozwiązanie................................................................................................... 338 29.4. Dodatkowe argumenty.......................................................................................... 340 29.5. Przykład................................................................................................................ 341 29.6. Formy skrócone.................................................................................................... 343 29.7. Przemyślenia ........................................................................................................ 344 29.8. Uwagi historyczne, źródła i podziękowania ......................................................... 345 Rozdział 30. Uniezależnianie bibliotek aplikacji od wejść i wyjść......................... 347 30.1. Problem ................................................................................................................ 347 30.2. Rozwiązanie 1. — spryt i metoda siłowa.............................................................. 348 30.3. Rozwiązanie 2. — abstrakcyjne wyjście .............................................................. 349 30.4. Rozwiązanie 3. — spryt bez metody siłowej........................................................ 351 30.5. Uwagi ................................................................................................................... 354 Część VI Podsumowanie.............................................................355 Rozdział 31. Przez złożoność do prostoty............................................................ 357 31.1. Świat jest zło ony................................................................................................. 357 31.2. Zło oność staje się ukryta..................................................................................... 358 31.3. Komputery mają to samo...................................................................................... 359 31.4. Komputery rozwiązują prawdziwe problemy ....................................................... 361 31.5. Biblioteki klas i semantyka języka ....................................................................... 362 31.6. Ułatwianie jest trudne........................................................................................... 364 31.7. Abstrakcja a interfejs ............................................................................................ 365 31.8. Konserwacja zło oności ....................................................................................... 366
  • 7. 10 Język C++. Koncepcje i techniki programowania Rozdział 32. „Witaj świecie” i co dalej?............................................................. 367 32.1. Znajdź w pobli u eksperta.................................................................................... 367 32.2. Wybierz narzędzie i opanuj je .............................................................................. 368 32.3. Niektóre elementy C są wa ne….......................................................................... 368 32.4. …inne niekoniecznie ............................................................................................ 370 32.5. Wyznacz sobie szereg problemów do rozwiązania............................................... 371 32.6. Konkluzja ............................................................................................................. 374 Dodatki .......................................................................................377 Skorowidz...................................................................................... 379
  • 8. Rozdział 5. Klasy surogatów Jak zaprojektować zasobnik C++, który potencjalnie mo e zawierać obiekty ró nych, ale powiązanych ze sobą typów? Ju samo przechowywanie obiektów w zasobniku jest trudne, poniewa zasobniki generalnie przechowują obiekty jednego typu. Prze- chowywanie wskaźników obiektów, mimo e pozwala na obsługę ró nych typów z po- mocą dziedziczenia, wią e się z koniecznością przydziału dodatkowej pamięci. Przyjrzymy się tutaj jednemu ze sposobów rozwiązania tego problemu, polegającemu na zdefiniowaniu obiektów zwanych surogatami, które zachowują się niemal tak, jak obiekty, które reprezentują, ale pozwalają na sprowadzenie całej hierarchii typów do jednego tylko typu. Surogaty to najprostsza postać klas uchwytów, opisanych we wstępie do tej części ksią ki. W kolejnych rozdziałach rozwinięte zostaną przedsta- wione tu ogólnie zagadnienia. 5.1. Problem Przypuśćmy, e mamy hierarchię klas, która reprezentuje ró ne rodzaje środków transportu: ENCUU 8GJKENG ] RWDNKE XKTVWCN FQWDNG YGKIJV EQPUV XKTVWCN XQKF UVCTV _ ENCUU 4QCF8GJKENG RWDNKE 8GJKENG ]
  • 9. _ ENCUU #WVQOQDKNG RWDNKE 4QCF8GJKENG ]
  • 10. _ ENCUU #KTETCHV RWDNKE 8GJKENG ]
  • 11. _ ENCUU *GNKEQRVGT RWDNKE #KTETCHV ]
  • 12. _ i tak dalej. Wszystkie środki transportu (8GJKENG) mają pewne wspólne właściwości, które opisują składowe klasy 8GJKENG. Jednak niektóre z nich mają właściwości, których nie posiadają inne. Na przykład, tylko samolot (#KTETCHV) mo e latać, a tylko helikopter (*GNKEQRVGT) mo e wykonywać lot wiszący.
  • 13. 62 Część II ♦ Klasy i dziedziczenie Załó my teraz, e chcemy śledzić zbiór ró nego rodzaju środków transportu (8GJKENG). W praktyce zastosowalibyśmy zapewne pewien rodzaj klasy zasobnika. Jednak, dla uproszczenia przykładu, zadowolimy się tablicą. Spróbujmy więc: 8GJKENG RCTMKPIANQV=? Nie udało się. Dlaczego? Na pozór powodem jest to, e 8GJKENG jest abstrakcyjną klasą bazową — w końcu jej funkcje składowe YGKIJV i UVCTV to funkcje czysto abstrakcyjne. Poprzez dopisanie w deklaracjach, funkcje te pozostały jawnie niezdefiniowane. Wynika z tego, e nie mogą istnieć obiekty klasy 8GJKENG, a jedynie obiekty klas potomnych klasie 8GJKENG. Je eli nie mogą istnieć obiekty 8GJKENG, niemo liwe jest równie stworzenie tablicy takich obiektów. Istnieje te głębsza przyczyna naszego niepowodzenia, którą mo na odkryć zadając sobie pytanie: co stałoby się, gdyby istnienie obiektów klasy 8GJKENG było mimo wszys- tko mo liwe. Powiedzmy, e pozbyliśmy się wszystkich czysto wirtualnych funkcji z klasy 8GJKENG i napisaliśmy: #WVQOQDKNG Z
  • 14. RCTMKPIANQV=PWOAXGJKENGU ? Z Przyporządkowanie Z elementowi tablicy RCTMKPIANQV spowoduje konwersję Z na typ 8GJKENG drogą odrzucenia wszystkich składowych, które nie stanowią części samej klasy 8GJKENG. Dopiero potem operacja przyporządkowania skopiuje ten (okrojony) obiekt do tablicy RCTMKPIANQV. W efekcie zdefiniowaliśmy RCTMKPIANQV jako zbiór obiektów 8GJKENG, a nie zbiór obiek- tów klas potomnych klasie 8GJKENG. 5.2. Rozwiązanie klasyczne Normalnym sposobem na osiągnięcie elastyczności w tego typu sytuacjach jest wpro- wadzenie pośredniości. Najprostsza, mo liwa tu do zastosowania forma pośredniości sprowadza się do przechowywania wskaźników, zamiast samych obiektów: 8GJKENG
  • 15. RCTMKPIANQV=? // tablica wskaźników Potem mo emy napisać: #WVQOQDKNG Z
  • 16. RCTMKPIANQV=PWOAXGJKENGU ? Z Tym sposobem pozbywamy się bezpośredniego problemu, ale pojawiają się dwa inne. Po pierwsze, to co zachowaliśmy w RCTMKPIANQV, to wskaźnik do Z, który w tym przy- kładzie jest zmienną lokalną. Wobec tego, gdy tylko zmienna Z przestanie być widoczna (dostępna), RCTMKPIANQV przestanie cokolwiek wskazywać.
  • 17. Rozdział 5. ♦ Klasy surogatów 63 Nowo powstały problem mo na by rozwiązać, przechowując w RCTMKPIANQV wskaź- niki nie do oryginalnych obiektów, ale do ich kopii. Wówczas wypadałoby równie przyjąć konwencję, e uwalniając RCTMKPIANQV uwalniamy równie obiekty, na które tablica ta wskazuje. Poprzedni przykład przybiera więc następującą postać: #WVQOQDKNG Z
  • 18. RCTMKPIANQV=PWOAXGJKENGU ? PGY #WVQOQDKNG Z Co prawda w efekcie takiej zmiany tablica nie przechowuje ju wskaźników do lokal- nych obiektów, ale w zamian spływa na nas cię ar dynamicznego zarządzania pamię- cią. Co więcej, technika ta działa tylko wtedy, gdy znany jest statyczny typ obiektów, jakie mają być umieszczone w RCTMKPIANQV. A co, je eli nie znamy tych typów? Po- wiedzmy na przykład, e chcemy sprawić, by element RCTMKPIANQV=R? wskazywał na nowo utworzony RCTMKPIANQV=S?? Nie mo emy napisać: KH R S ] FGNGVG RCTMKPIANQV=R? RCTMKPIANQV=R? RCTMKPIANQV=S? _ poniewa elementy RCTMKPIANQV=R?i RCTMKPIANQV=S? wskazywały by wówczas ten sam obiekt. Nie mo emy te napisać: KH R S ] FGNGVG RCTMKPIANQV=R? RCTMKPIANQV=R? PGY 8GJKENG RCTMKPIANQV=S? _ poniewa ponownie stanęlibyśmy przed obliczem wcześniejszego problemu — obiekty typu 8GJKENG przecie nie mogą istnieć, a nawet gdyby mogły, to są niepo ądane! 5.3. Wirtualne funkcje kopiujące Spróbujmy znaleźć sposób na tworzenie kopii obiektów, których typ nie jest znany w chwili kompilacji. Wiadomo, e aby zrobić cokolwiek z obiektami nieokreślonego typu w C++ nale y posłu yć się funkcją wirtualną. Narzucająca się nazwa dla takiej funkcji to EQR[ lub ENQPG. Jako e najprowdopodobniej zale y nam na mo liwości kopiowania dowolnego typu obiektów 8GJKENG, powinniśmy rozbudować klasę 8GJKENG o stosowną, czysto wirtu- alną funkcję: ENCUU 8GJKENG ] RWDNKE XKTVWCN FQWDNG YGKIJV EQPUV XKTVWCN XQKF UVCTV XKTVWCN 8GJKENG
  • 19. EQR[ EQPUV _ Następnie zdefiniujemy kopię funkcji składowej w ka dej klasie potomnej 8GJKENG. Idea polega na tym, e je eli XR wskazuje na obiekt pewnej nieustalonej klasy, potomnej
  • 20. 64 Część II ♦ Klasy i dziedziczenie wobec klasy 8GJKENG, to XR EQR[ da wskaźnik do nowo utworzonej kopii obiektu. Je eli, na przykład, klasa 6TWEM jest potomkiem (bezpośrednim lub pośrednim) klasy 8GJKENG, to jej funkcja EQR[ wygląda tak: 8GJKENG
  • 21. 6TWEMEQR[ EQPUV ] TGVWTP PGY 6TWEM
  • 22. VJKU_ _ Oczywiście kiedy obiekt przestaje być potrzebny, będziemy chcieli się go pozbyć. Trzeba więc dopisać do klasy 8GJKENG wirtualny destruktor: ENCUU 8GJKENG ] RWDNKE XKTVWCN FQWDNG YGKIJV EQPUV XKTVWCN XQKF UVCTV XKTVWCN 8GJKENG
  • 23. EQR[ EQPUV XKTVWCN `8GJKENG ] _ _ 5.4. Definiowanie klasy surogatu Wiemy ju , w jaki sposób mo na dowolnie kopiować obiekty. Zajmijmy się teraz przy- działem pamięci. Czy mo na w jakiś sposób uniknąć konieczności jawnego zajmowa- nia się przydziałem pamięci, zachowując jednocześnie mo liwości klasy 8GJKENG w za- kresie tworzenia dynamicznych powiązań? W C++ często okazuje się, e kluczem do rozwiązania jest zastosowanie klas do repre- zentowania pojęć. Często korci mnie, by właśnie to spostrze enie uznać za fundamen- talną zasadę projektowania programów w C++. W kontekście kopiowania obiektów, zastosowanie tej reguły oznacza zdefiniowanie czegoś, co zachowuje się jak obiekt 8GJKENG, ale potencjalnie reprezentuje obiekt ka - dej klasy potomnej wobec klasy 8GJKENG. Obiekt takiej klasy mo na właśnie nazwać surogatem. Ka dy surogat klasy 8GJKENG będzie reprezentował obiekt jakiejś klasy, potomnej wo- bec klasy 8GJKENG. Obiekt ten będzie istniał tak długo, jak długo surogat pozostanie z nim skojarzony. Dlatego skopiowanie surogratu spowoduje skopiowanie odpowiada- jącego mu obiektu, a przypisanie surogatowi nowej wartości będzie polegać na usu- nięciu starego obiektu, przed skopiowaniem na jego miejsce nowego.1 Na szczęście wyposa yliśmy ju klasę 8GJKENG w wirtualną funkcję EQR[, która pozwala na tworze- nie takich kopii. Wobec tego surogat mo na zdefiniować następująco: 1 Jak zauwa ył Dag Bruck, zachowanie to subtelnie ró ni się od zwykle spodziewanego zachowania operatora przyporządkowania, poniewa zmienia typ obiektu, z którym skojarzony jest surogat występujący po lewej stronie operatora.
  • 24. Rozdział 5. ♦ Klasy surogatów 65 ENCUU 8GJKENG5WTTQICVG ] RWDNKE 8GJKENG5WTTQICVG 8GJKENG5WTTQICVG EQPUV 8GJKENG `8GJKENG5WTTQICVG 8GJKENG5WTTQICVG EQPUV 8GJKENG5WTTQICVG 8GJKENG5WTTQICVG QRGTCVQT EQPUV 8GJKENG5WTTQICVG RTKXCVG 8GJKENG
  • 25. XR _ Surogat ma konstruktor, który pobiera argument const 8GJKENG , co umo liwia tworze- nie surogratu ka dego obiektu klasy potomnej wobec klasy 8GJKENG. Klasa posiada rów- nie konstruktor domyślny, który umo liwia tworzenie tablic obiektów 8GJKENG5WTTQICVG. Konstruktor domyślny stwarza jednak pewien problem. Skoro 8GJKENG to abstrakcyjna klasa bazowa, to jakie domyślne zachowanie powinniśmy zdefiniować dla 8GJKENG 5WTTQICVG? Jaki jest typ obiektu, na który wskazuje? Nie mo e to być typ 8GJKENG, bo nie mogą istnieć obiekty 8GJKENG. Dla lepszego zrozumienia, wprowadzimy pojęcie surogatu pustego, który zachowuje się podobnie jak wskaźnik zerowy. Mo liwe będzie tworzenie, likwidacja i kopiowa- nie takich surogatów, ale ka da inna operacja będzie traktowana jako błąd. Jak dotąd, nie mamy jeszcze innych operacji — brak ten ułatwia uzupełnienie defini- cji funkcji składowych: 8GJKENG5WTTQICVG8GJKENG5WTTQICVG XR ] _ 8GJKENG5WTTQICVG8GJKENG5WTTQICVG EQPUV 8GJKENG X XR XEQR[ ] _ 8GJKENG5WTTQICVG`8GJKENG5WTTQICVG ] FGNGVG XR _ 8GJKENG5WTTQICVG8GJKENG5WTTQICVG EQPUV 8GJKENG5WTTQICVG X XR XXR! XXR EQR[ ] _ 8GJKENG5WTTQICVG 8GJKENG5WTTQICVGQRGTCVQT EQPUV 8GJKENG5WTTQICVG X ] KH VJKU X ] FGNGVG XR XR XXR ! XXR EQR[ _ TGVWTP
  • 26. VJKU _ Zastosowano tu trzy triki, które warto zapamiętać. Po pierwsze, jak widać, ka de wywołanie EQR[ jest wywołaniem wirtualnym. Wywo- łania te nie mogą być inne, poniewa obiekty klasy 8GJKENG nie istnieją. Nawet wywo- łanie XEQR[ w konstruktorze, które pobiera const 8GJKENG jest wirtualne, poniewa 8 to wskaźnik, a nie sam obiekt.
  • 27. 66 Część II ♦ Klasy i dziedziczenie Po drugie, w konstruktorze kopii i operatorze przyporządkowania występuje test, sprawdzający, czy XXR jest niezerowe. Jest to konieczne, poniewa w innym wypad- ku wywołanie XXR EQR[ zakończyłoby się błędem. Po trzecie, w operatorze przyporządkowania następuje sprawdzenie, czy surogat nie jest przyporządkowywany sobie samemu. Aby zakończyć tworzenie klasy surogatu, wystarczy jeszcze uzupełnić ją o obsługę innych operacji obsługiwanych przez klasę 8GJKENG. We wcześniejszym przykładzie były to funkcje YGKIJV i UVCTV, dodajmy je więc do klasy 8GJKENG5WTTQICVG: ENCUU 8GJKENG5WTTQICVG ] RWDNKE 8GJKENG5WTTQICVG 8GJKENG5WTTQICVG EQPUV 8GJKENG `8GJKENG5WTTQICVG 8GJKENG5WTTQICVG EQPUV 8GJKENG5WTTQICVG 8GJKENG5WTTQICVG QRGTCVQT EQPUV 8GJKENG5WTTQICVG // operacje z klasy 8GJKENG FQWDNG YGKIJV EQPUV XQKF UVCTV RTKXCVG 8GJKENG
  • 28. XR _ Jak widać, dodane funkcje nie są wirtualne — jedyne obiekty, jakich tutaj u ywamy, są klasy 8GJKENG5WTTQICVG. Nie ma tu obiektów jakiejkolwiek klasy potomnej 8GJKENG 5WTTQICVG. Oczywiście same funkcje wywołują wirtualne funkcje w odpowiadającym im obiekcie 8GJKENG. Funkcje te równie powinny sprawdzać, czy XR jest niezerowe: FQWDNG 8GJKENG5WTTQICVGYGKIJV EQPUV ] KH XR VJTQY GORV[ 8GJKENG5WTTQICVGYGKIJV TGVWTP XR YGKIJV _ XQKF 8GJKENG5WTTQICVGUVCTV ] KH XR VJTQY GORV[ 8GJKENG5WTTQICVGUVCTV XR UVCTV _ Po wykonaniu całej tej pracy, zdefiniowanie parkingu (RCTMKPIANQV) jest ju proste: 8GJKENG5WTTQICVG RCTMKPIANQV=? #WVQOQDKNG Z RCTMKPIANQV=PWOAXGJKENGU ? Z Ostatnia instrukcja jest to sama: RCTMKPIANQV=PWOAXGJKENGU ? 8GJKENG5WTTQICVG Z co powoduje stworzenie kopii obiektu :, wią e obiekt 8GJKENG5WTTQICVG z tą kopią, a następnie przyporządkowuje ten obiekt do elementu tablicy RCTMKPIANQV. Z chwilą usunięcia tablicy RCTMKPIANQV wszystkie te kopie równie zostaną usunięte.
  • 29. Rozdział 5. ♦ Klasy surogatów 67 5.5. Podsumowanie Połączenie dziedziczenia z zasobnikami zmusza do zajęcia się dwoma kwestiami: kontrolowaniem przydziału pamięci oraz umieszczaniem obiektów ró nych typów w jednym zasobniku. Obydwie te kwestie mo na rozwiązać posługując się fundamen- talną techniką w C++ polegającą na reprezentowaniu pojęć za pomocą klas. W ten spo- sób otrzymamy pojedynczą klasę zwaną surogatem, której ka dy obiekt reprezentuje je- den inny obiekt o klasie dowolnej spośród całej hierarchii. Problem rozwiązujemy umieszczając w miejsce obiektów w naszym zasobniku reprezentujące je surogaty.