Poznaj możliwości i mechanizmy C++ stosowane przez profesjonalistów
Efektywne zarządzanie pamięcią
Obsługa błędów
Biblioteki i wzorce projektowe
Język C++ od dawna cieszy się zasłużoną popularnością wśród twórców oprogramowania. Jednak często nawet najbardziej doświadczeni programiści nie wykorzystują wszystkich jego możliwości. W opracowaniach dotyczących tego języka najczęściej omawiana jest składnia i elementy języka, a znacznie rzadziej -- jego praktyczne zastosowania. Brak odniesień do praktyki powoduje nieznajomość wielu niezwykle przydatnych i ułatwiających pracę aspektów C++ i nadmierne eksploatowanie prostych, książkowych konstrukcji.
Książka 'C++. Zaawansowane programowanie' to przegląd metod programowania nie omawianych w większości publikacji. Ten przeznaczony dla średnio zaawansowanych programistów podręcznik przedstawia zasady stosowania C++ do rozwiązywania prawdziwych problemów. Opisuje nieznane możliwości znacznie przyspieszające i usprawniające pracę, sposoby tworzenia przenośnego kodu oraz testowania oprogramowania. Książka zawiera również omówienie biblioteki standardowej C++ oraz wzorców projektowych.
Zasady tworzenia projektów w C++
Projektowanie obiektowe
Korzystanie z biblioteki standardowej C++
Tworzenie kodu przeznaczonego do wielokrotnego zastosowania
Styl kodowania
Zarządzanie pamięcią
Procedury obsługi wyjątków
Przeciążanie operatorów
Tworzenie aplikacji wieloplatformowych
Testowanie kodu i usuwanie błędów
Programowanie rozproszone
Stosowanie wzorców projektowych
Naucz się korzystać z C++ tak, jak robią to profesjonaliści.
Znajdź podobne książki
Ostatnio czytane w tej kategorii
Darmowy fragment publikacji:
IDZ DO
IDZ DO
PRZYK£ADOWY ROZDZIA£
PRZYK£ADOWY ROZDZIA£
SPIS TREŒCI
SPIS TREŒCI
KATALOG KSI¥¯EK
KATALOG KSI¥¯EK
KATALOG ONLINE
KATALOG ONLINE
ZAMÓW DRUKOWANY KATALOG
ZAMÓW DRUKOWANY KATALOG
TWÓJ KOSZYK
TWÓJ KOSZYK
DODAJ DO KOSZYKA
DODAJ DO KOSZYKA
CENNIK I INFORMACJE
CENNIK I INFORMACJE
ZAMÓW INFORMACJE
ZAMÓW INFORMACJE
O NOWOŒCIACH
O NOWOŒCIACH
ZAMÓW CENNIK
ZAMÓW CENNIK
CZYTELNIA
CZYTELNIA
FRAGMENTY KSI¥¯EK ONLINE
FRAGMENTY KSI¥¯EK ONLINE
Wydawnictwo Helion
ul. Chopina 6
44-100 Gliwice
tel. (32)230-98-63
e-mail: helion@helion.pl
C++. Zaawansowane
programowanie
Autorzy: Nicholas A. Solter, Scott J. Kleper
T³umaczenie: Pawe³ Gonera, Rafa³ Joñca, Tomasz ¯mijewski
ISBN: 83-7361-998-4
Tytu³ orygina³u: Professional C++
Format: B5, stron: 912
Poznaj mo¿liwoœci i mechanizmy C++ stosowane przez profesjonalistów
• Efektywne zarz¹dzanie pamiêci¹
• Obs³uga b³êdów
• Biblioteki i wzorce projektowe
Jêzyk C++ od dawna cieszy siê zas³u¿on¹ popularnoœci¹ wœród twórców
oprogramowania. Jednak czêsto nawet najbardziej doœwiadczeni programiœci nie
wykorzystuj¹ wszystkich jego mo¿liwoœci. W opracowaniach dotycz¹cych tego jêzyka
najczêœciej omawiana jest sk³adnia i elementy jêzyka, a znacznie rzadziej — jego
praktyczne zastosowania. Brak odniesieñ do praktyki powoduje nieznajomoœæ wielu
niezwykle przydatnych i u³atwiaj¹cych pracê aspektów C++ i nadmierne
eksploatowanie prostych, ksi¹¿kowych konstrukcji.
Ksi¹¿ka „C++. Zaawansowane programowanie” to przegl¹d metod programowania nie
omawianych w wiêkszoœci publikacji. Ten przeznaczony dla œrednio zaawansowanych
programistów podrêcznik przedstawia zasady stosowania C++ do rozwi¹zywania
prawdziwych problemów. Opisuje nieznane mo¿liwoœci znacznie przyspieszaj¹ce
i usprawniaj¹ce pracê, sposoby tworzenia przenoœnego kodu oraz testowania
oprogramowania. Ksi¹¿ka zawiera równie¿ omówienie biblioteki standardowej C++
oraz wzorców projektowych.
• Zasady tworzenia projektów w C++
• Projektowanie obiektowe
• Korzystanie z biblioteki standardowej C++
• Tworzenie kodu przeznaczonego do wielokrotnego zastosowania
• Styl kodowania
• Zarz¹dzanie pamiêci¹
• Procedury obs³ugi wyj¹tków
• Przeci¹¿anie operatorów
• Tworzenie aplikacji wieloplatformowych
• Testowanie kodu i usuwanie b³êdów
• Programowanie rozproszone
• Stosowanie wzorców projektowych
Naucz siê korzystaæ z C++ tak, jak robi¹ to profesjonaliœci
Spis treści
O autorach ................................................................................................................................................ 17
Wprowadzenie ......................................................................................................................................... 19
Część I Wprowadzenie do profesjonalnego C++ .............................................................23
Rozdział 1. Skrócony kurs C++ ...............................................................................................................25
Podstawy C++ ............................................................................................................. 25
Teraz obowiązkowo Hello, World .............................................................................. 26
Przestrzenie nazw ................................................................................................... 28
Zmienne ................................................................................................................ 30
Operatory ............................................................................................................... 32
Typy danych ........................................................................................................... 34
Wyrażenia warunkowe ............................................................................................. 36
Pętle ...................................................................................................................... 38
Tablice ................................................................................................................... 40
Funkcje .................................................................................................................. 41
To był elementarz ................................................................................................... 42
C++ z bliska ................................................................................................................ 42
Wskaźniki i pamięć alokowana dynamicznie .............................................................. 42
Łańcuchy znakowe w C++ ........................................................................................ 45
Referencje ............................................................................................................. 47
Wyjątki ................................................................................................................... 48
Wiele zastosowań słowa kluczowego const ............................................................... 49
C++ jako język obiektowy .............................................................................................. 50
Deklarowanie klasy ................................................................................................. 51
Nasz pierwszy praktyczny program C++ .......................................................................... 53
System obsługi kadrowej ......................................................................................... 53
Klasa Employee ...................................................................................................... 54
Klasa Database ...................................................................................................... 58
Interfejs użytkownika ............................................................................................... 62
Udoskonalanie programu ......................................................................................... 65
Podsumowanie ............................................................................................................ 65
Rozdział 2. Tworzenie profesjonalnych programów w C++ ................................................................67
Czym jest projekt programu? ......................................................................................... 68
Dlaczego projekt programu jest tak ważny? .................................................................... 68
Co jest szczególnego w projektach C++? ....................................................................... 70
Dwie zasady tworzenia projektów w C++ ........................................................................ 71
Abstrakcja .............................................................................................................. 71
Wielokrotne użycie .................................................................................................. 73
6
C++. Zaawansowane programowanie
Projektowanie programu szachowego ............................................................................. 75
Wymagania ............................................................................................................ 75
Kolejne etapy projektowania .................................................................................... 76
Podsumowanie ............................................................................................................ 80
Rozdział 3. Projektowanie obiektowe ....................................................................................................83
Obiektowe spojrzenie na świat ...................................................................................... 83
Czy myślę proceduralnie? ........................................................................................ 83
Filozofia obiektowa ................................................................................................. 84
W świecie obiektów ................................................................................................ 87
Powiązania obiektów ............................................................................................... 89
Abstrakcja .............................................................................................................. 99
Podsumowanie .......................................................................................................... 102
Rozdział 4. Użycie bibliotek i wzorców ................................................................................................ 103
Wielokrotne użycie kodu ............................................................................................. 103
Uwaga na temat terminologii ................................................................................. 104
Podejmowanie decyzji, czy ponownie wykorzystać kod .............................................. 105
Strategie wielokrotnego użycia kodu ....................................................................... 107
Korzystanie z obcych aplikacji ................................................................................ 112
Biblioteki open-source ........................................................................................... 113
Standardowa biblioteka C++ .................................................................................. 114
Projektowanie z użyciem wzorców i technik ................................................................... 127
Techniki projektowe .............................................................................................. 128
Wzorce projektowe ................................................................................................ 129
Podsumowanie .......................................................................................................... 130
Rozdział 5. Projektowanie z myślą o ponownym użyciu ......................................................................131
Filozofia wielokrotnego użycia ..................................................................................... 132
Jak projektować kod wielokrotnego użycia .................................................................... 132
Użycie abstrakcji ................................................................................................... 133
Struktura kodu wielokrotnego użycia ....................................................................... 134
Projektowanie interfejsów ...................................................................................... 139
Łączenie ogólności i prostoty użycia ....................................................................... 145
Podsumowanie .......................................................................................................... 146
Rozdział 6. Użycie metod inżynierii oprogramowania ........................................................................ 147
Potrzeba stosowania procesu ..................................................................................... 147
Modele cyklu życia oprogramowania ............................................................................ 149
Model etapowy i kaskadowy .................................................................................. 149
Metoda spirali ...................................................................................................... 152
Rational Unified Process ....................................................................................... 154
Metodyki inżynierii oprogramowania ............................................................................. 155
Programowanie ekstremalne (XP) ........................................................................... 156
Sąd nad oprogramowaniem ................................................................................... 160
Tworzenie własnego procesu i metodyki ....................................................................... 161
Bądź otwarty na nowe pomysły .............................................................................. 161
Dziel się pomysłami .............................................................................................. 161
Zorientuj się, co działa, a co nie ............................................................................ 162
Nie bądź renegatem .............................................................................................. 162
Podsumowanie .......................................................................................................... 162
Spis treści
7
Część II Profesjonalne kodowanie w C++ .......................................................................163
Rozdział 7. Styl kodowania .................................................................................................................... 165
Piękny wygląd ............................................................................................................ 165
Myślenie o przyszłości ........................................................................................... 165
Zachowanie porządku ............................................................................................ 166
Elementy dobrego stylu ......................................................................................... 166
Dokumentowanie kodu ............................................................................................... 166
Po co pisać komentarze ........................................................................................ 166
Style komentowania .............................................................................................. 169
Komentarze w tej książce ...................................................................................... 174
Dekompozycja ........................................................................................................... 174
Dekompozycja przez refaktoring ............................................................................. 174
Dekompozycja na etapie projektu ........................................................................... 176
Dekompozycja w tej książce ................................................................................... 176
Nazewnictwo ............................................................................................................. 176
Dobór właściwej nazwy .......................................................................................... 177
Konwencje nazewnicze .......................................................................................... 177
Elementy języka a styl ................................................................................................ 180
Stałe ................................................................................................................... 180
Korzystanie ze zmiennych const ............................................................................. 180
Użycie referencji zamiast wskaźników ..................................................................... 180
Wyjątki użytkownika .............................................................................................. 181
Formatowanie ............................................................................................................ 181
Rozmieszczenie nawiasów klamrowych ................................................................... 182
Spacje i nawiasy ................................................................................................... 183
Spacje i tabulatory ................................................................................................ 183
Wyzwania związane ze stylem ..................................................................................... 183
Podsumowanie .......................................................................................................... 184
Rozdział 8. Poznajemy lepiej klasy i obiekty ........................................................................................ 185
Wprowadzenie do przykładu arkusza kalkulacyjnego .......................................................... 185
Pisanie klas .............................................................................................................. 186
Definicje klasy ...................................................................................................... 186
Definiowanie metod .............................................................................................. 188
Użycie obiektów .................................................................................................... 192
Cykl życia obiektów .................................................................................................... 193
Tworzenie obiektu ................................................................................................. 193
Usuwanie obiektu ................................................................................................. 204
Przypisania do obiektów ........................................................................................ 206
Odróżnianie kopiowania od przypisania ................................................................... 208
Podsumowanie .......................................................................................................... 210
Rozdział 9. Doskonalenie znajomości klas i obiektów ..........................................................................211
Dynamiczna alokacja pamięci w obiektach ................................................................... 211
Klasa Spreadsheet ............................................................................................... 212
Zwalnianie pamięci w destruktorach ....................................................................... 213
Obsługa kopiowania i przypisania ........................................................................... 214
Różne rodzaje pól w klasach ....................................................................................... 221
Pola statyczne ...................................................................................................... 221
Pola stałe ............................................................................................................ 223
8
C++. Zaawansowane programowanie
Pola będące referencjami ...................................................................................... 225
Pola będące stałymi referencjami ........................................................................... 226
Jeszcze o metodach ................................................................................................... 226
Metody statyczne .................................................................................................. 226
Metody stałe ........................................................................................................ 227
Przeciążanie metod ............................................................................................... 229
Parametry domyślne ............................................................................................. 230
Metody inline ....................................................................................................... 231
Klasy zagnieżdżone .................................................................................................... 233
Zaprzyjaźnienie .......................................................................................................... 235
Przeciążanie operatorów ............................................................................................. 236
Implementacja dodawania ..................................................................................... 236
Przeciążanie operatorów arytmetycznych ................................................................. 240
Przeciążanie operatorów porównania ...................................................................... 242
Tworzenie typów z przeciążaniem operatorów .......................................................... 244
Wskaźniki pól i metod ................................................................................................ 244
Tworzenie klas abstrakcyjnych .................................................................................... 245
Użycie klas interfejsu i implementacji ..................................................................... 246
Podsumowanie .......................................................................................................... 249
Rozdział 10. Przygoda z dziedziczeniem .............................................................................................. 251
Klasy i dziedziczenie .................................................................................................. 251
Rozszerzanie klas ................................................................................................. 252
Nadpisywanie metod ............................................................................................. 255
Dziedziczenie a wielokrotne użycie kodu ...................................................................... 258
Klasa WeatherPrediction ....................................................................................... 258
Nowe możliwości w podklasie ................................................................................ 259
Inne możliwości w podklasie .................................................................................. 261
Szacunek dla rodziców ............................................................................................... 262
Konstruktory rodziców ........................................................................................... 262
Destruktory rodziców ............................................................................................. 264
Odwołania do danych rodziców ............................................................................... 266
Rzutowanie w górę i w dół ..................................................................................... 267
Dziedziczenie i polimorfizm ......................................................................................... 268
Powrót do arkusza kalkulacyjnego .......................................................................... 269
Polimorficzna komórka arkusza .............................................................................. 269
Klasa bazowa komórki arkusza .............................................................................. 270
Poszczególne podklasy .......................................................................................... 272
Polimorfizm dla zaawansowanych ........................................................................... 274
Uwagi na przyszłość .............................................................................................. 275
Dziedziczenie wielokrotne ........................................................................................... 276
Dziedziczenie po wielu klasach .............................................................................. 277
Kolizje nazw i niejednoznaczne klasy bazowe .......................................................... 278
Ciekawostki i tajemnice dziedziczenia .......................................................................... 281
Zmiana charakterystyki nadpisanej metody ............................................................. 281
Przypadki szczególne nadpisywania metod .............................................................. 285
Konstruktory kopiujące i operator równości ............................................................. 291
Prawda o wirtualności ........................................................................................... 293
Typy podczas działania programu ........................................................................... 296
Dziedziczenie niepubliczne .................................................................................... 297
Wirtualne klasy bazowe ......................................................................................... 298
Podsumowanie .......................................................................................................... 299
Spis treści
9
Rozdział 11. Szablony i kod ogólny ......................................................................................................... 301
Szablony w skrócie ..................................................................................................... 302
Szablony klas ............................................................................................................ 303
Pisanie szablonu klasy .......................................................................................... 303
Jak kompilator przetwarza szablony ........................................................................ 311
Rozdzielanie kodu szablonu między pliki ................................................................. 312
Parametry szablonów ............................................................................................ 313
Szablony metod .................................................................................................... 316
Specjalizacja klas szablonów ................................................................................. 321
Podklasy szablonów klas ....................................................................................... 324
Dziedziczenie a specjalizacja ................................................................................. 325
Szablony funkcji ......................................................................................................... 326
Specjalizacja szablonów funkcji .............................................................................. 327
Przeciążanie szablonów funkcji .............................................................................. 327
Szablony funkcji zaprzyjaźnionych szablonów klas .................................................... 328
Szablony: zagadnienia zaawansowane ......................................................................... 330
Więcej o parametrach szablonów ........................................................................... 330
Częściowa specjalizacja szablonów klas ................................................................. 338
Przeciążanie jako symulacja specjalizacji częściowej funkcji ..................................... 344
Szablony rekurencyjnie .......................................................................................... 345
Podsumowanie .......................................................................................................... 353
Rozdział 12. Dziwactwa C++ ................................................................................................................. 355
Referencje ................................................................................................................. 355
Zmienne referencyjne ............................................................................................ 356
Referencje do pól ................................................................................................. 358
Parametry referencyjne .......................................................................................... 358
Zwracanie wartości przez referencję ....................................................................... 359
Wybór między referencjami a wskaźnikami .............................................................. 360
Zamieszanie ze słowami kluczowymi ............................................................................ 362
Słowo kluczowe const ........................................................................................... 362
Słowo kluczowe static ........................................................................................... 365
Porządek inicjalizacji zmiennych nielokalnych .......................................................... 369
Typy i rzutowanie ....................................................................................................... 369
typedef ................................................................................................................ 370
Rzutowanie .......................................................................................................... 371
Zasięg ...................................................................................................................... 375
Pliki nagłówkowe ........................................................................................................ 376
Narzędzia C ............................................................................................................... 377
Listy parametrów o zmiennej długości .................................................................... 378
Makra preprocesora .............................................................................................. 380
Podsumowanie .......................................................................................................... 381
Część III Zaawansowane elementy C++ .........................................................................383
Rozdział 13. Skuteczne zarządzanie pamięcią .................................................................................... 385
Użycie pamięci dynamicznej ........................................................................................ 385
Jak sobie wyobrazić pamięć ................................................................................... 386
Alokacja i zwalnianie ............................................................................................. 387
Tablice ................................................................................................................. 389
Użycie wskaźników ................................................................................................ 396
10
C++. Zaawansowane programowanie
Dualność tablic i wskaźników ...................................................................................... 398
Tablice są wskaźnikami! ........................................................................................ 398
Nie wszystkie wskaźniki są tablicami! ..................................................................... 399
Łańcuchy dynamiczne ................................................................................................. 400
Łańcuchy w stylu C ............................................................................................... 400
Literały łańcuchowe .............................................................................................. 402
Klasa C++ string .................................................................................................. 402
Niskopoziomowe operacje na pamięci ......................................................................... 404
Arytmetyka wskaźników ......................................................................................... 405
Specjalne zarządzanie pamięcią ............................................................................. 405
Odśmiecanie pamięci ............................................................................................ 406
Pule obiektów ....................................................................................................... 407
Wskaźniki funkcji .................................................................................................. 407
Typowe błędy związane z zarządzaniem pamięcią .......................................................... 409
Brak pamięci na łańcuchy ...................................................................................... 409
Wycieki pamięci .................................................................................................... 410
Dwukrotne usuwanie i błędne wskaźniki ................................................................. 413
Dostęp do pamięci spoza zakresu .......................................................................... 414
Podsumowanie .......................................................................................................... 414
Rozdział 14. Wejście-wyjście w C++. Pożegnanie z mitami ................................................................ 415
Użycie strumieni ........................................................................................................ 416
Czym jest strumień ............................................................................................... 416
Źródła i przeznaczenie strumieni ............................................................................ 416
Strumienie wyjściowe ............................................................................................ 417
Strumienie wejściowe ........................................................................................... 421
Wejście i wyjście realizowane za pomocą obiektów .................................................. 426
Strumienie łańcuchowe .............................................................................................. 428
Strumienie plikowe .................................................................................................... 429
Poruszanie się za pomocą seek() i tell() .................................................................. 430
Wiązanie strumieni ............................................................................................... 432
Wejście-wyjście dwukierunkowe ................................................................................... 433
Internacjonalizacja ..................................................................................................... 435
Znaki rozszerzone ................................................................................................. 435
Zestawy znaków inne niż zachodnie ........................................................................ 436
Ustawienia lokalne i fazy ....................................................................................... 436
Podsumowanie .......................................................................................................... 438
Rozdział 15. Obsługa błędów ................................................................................................................ 439
Błędy i wyjątki ............................................................................................................ 440
Czym są wyjątki .................................................................................................... 440
Zalety wyjątków języka C++ ................................................................................... 441
Wady wyjątków języka C++ .................................................................................... 442
Zalecenia ............................................................................................................. 442
Mechanika wyjątków .................................................................................................. 443
Zgłaszanie i wyłapywanie wyjątków ......................................................................... 443
Typy wyjątków ....................................................................................................... 445
Zgłaszanie i wyłapywanie wielu wyjątków ................................................................. 447
Niewyłapane wyjątki .............................................................................................. 449
Lista zgłaszanych wyjątków .................................................................................... 451
Spis treści
11
Wyjątki i polimorfizm .................................................................................................. 455
Hierarchia standardowych wyjątków ........................................................................ 455
Przechwytywanie wyjątków w hierarchii klas ............................................................ 456
Pisanie własnych klas wyjątków ............................................................................. 458
Odwijanie stosu i zwalnianie zasobów .......................................................................... 461
Złap wyjątek, dokonaj zwolnienia zasobu i ponownie zgłoś wyjątek ............................ 462
Wykorzystanie inteligentnych wskaźników ............................................................... 463
Typowe zagadnienia dotyczące obsługi błędów ............................................................. 463
Błędy alokacji pamięci ........................................................................................... 463
Błędy w konstruktorach ......................................................................................... 466
Błędy w destruktorze ............................................................................................. 467
Połączenie wszystkiego razem ..................................................................................... 468
Podsumowanie .......................................................................................................... 470
Część IV Pozbywanie się błędów .....................................................................................471
Rozdział 16. Przeciążanie operatorów języka C++ ............................................................................ 473
Omówienie przeciążania operatorów ............................................................................ 474
Powody przeciążania operatorów ............................................................................ 474
Ograniczenia przeciążania operatorów .................................................................... 474
Wybór przeciążania operatorów .............................................................................. 475
Operatory, których nie należy przeciążać ................................................................. 478
Podsumowanie operatorów z możliwością przeciążania ............................................ 478
Przeciążanie operatorów arytmetycznych ...................................................................... 481
Przeciążanie jednoargumentowego operatora plus i minus ....................................... 481
Przeciążanie inkrementacji i dekrementacji ............................................................. 482
Przeciążanie operatorów bitowych i operatorów logicznych dwuargumentowych ................ 484
Przeciążanie operatorów wstawiania i wydobywania ...................................................... 484
Przeciążanie operatora indeksu tablicy ......................................................................... 486
Zapewnienie dostępu tylko do odczytu dla operatora operator[] ................................ 489
Indeksy niebędące liczbami całkowitymi ................................................................. 490
Przeciążenie operatora wywołania funkcji ..................................................................... 491
Przeciążanie operatorów dereferencji ........................................................................... 493
Implementacja operatora operator* ....................................................................... 494
Implementacja operatora operator- ....................................................................... 495
Co oznacza operator- *? ....................................................................................... 496
Pisanie operatorów konwersji ...................................................................................... 496
Problemy niejednoznaczności operatorów konwersji ................................................. 498
Konwersje dla wyrażeń logicznych .......................................................................... 498
Przeciążanie operatorów alokacji i zwalniania pamięci ................................................... 500
Jak tak naprawdę działają operatory new i delete .................................................... 501
Przeciążanie operatorów new i delete ..................................................................... 502
Przeciążanie operatorów new i delete z dodatkowymi parametrami ........................... 505
Podsumowanie .......................................................................................................... 507
Rozdział 17. Pisanie wydajnego kodu .................................................................................................. 509
Omówienie wydajności i efektywności .......................................................................... 509
Dwa podejścia do efektywności .............................................................................. 510
Dwa rodzaje programów ........................................................................................ 510
Czy C++ to nieefektywny język programowania? ....................................................... 510
12
C++. Zaawansowane programowanie
Efektywność na poziomie języka .................................................................................. 511
Wydajna obsługa obiektów .................................................................................... 512
Nie nadużywaj kosztownych elementów języka ........................................................ 515
Użycie metod i funkcji rozwijanych w miejscu wywołania ........................................... 516
Efektywność na poziomie projektu ............................................................................... 517
Stosuj buforowanie podręczne, jeśli tylko to możliwe ............................................... 517
Pule obiektów ....................................................................................................... 518
Wykorzystanie puli wątków .................................................................................... 523
Profilowanie ............................................................................................................... 524
Profilowanie przykładu za pomocą gprof .................................................................. 524
Podsumowanie .......................................................................................................... 533
Rozdział 18. Tworzenie aplikacji wieloplatformowych i wielojęzykowych ....................................... 535
Tworzenie aplikacji wieloplatformowych ........................................................................ 536
Kwestie architektury ............................................................................................. 536
Kwestie implementacji .......................................................................................... 539
Elementy specyficzne dla platformy programowo-sprzętowej ..................................... 540
Aplikacje wielojęzykowe .............................................................................................. 541
Mieszanie języków C i C++ .................................................................................... 541
Zmieszane paradygmaty ........................................................................................ 542
Konsolidacja kodu języka C ................................................................................... 545
Łączenie Javy i C++ dzięki JNI ................................................................................ 546
Mieszanie C++ z Perlem i skryptami powłoki ........................................................... 549
Mieszanie C++ z kodem w języku asemblera ........................................................... 552
Podsumowanie .......................................................................................................... 552
Rozdział 19. Podstawy testowania ....................................................................................................... 553
Kontrola jakości ......................................................................................................... 554
Kto jest odpowiedzialny za testowanie? .................................................................. 554
Cykl życia błędu .................................................................................................... 554
Narzędzia do śledzenia błędów .............................................................................. 555
Testy jednostkowe ..................................................................................................... 556
Metody testowania jednostkowego ......................................................................... 557
Proces testowania jednostkowego ......................................................................... 558
Testy jednostkowe w praktyce ................................................................................ 562
Testowanie wyższego poziomu .................................................................................... 570
Testy integracyjne ................................................................................................. 571
Testy systemowe .................................................................................................. 572
Testy regresyjne ................................................................................................... 573
Wskazówki na temat testowania ................................................................................. 574
Podsumowanie .......................................................................................................... 574
Rozdział 20. Wszystko o debugowaniu ............................................................................................... 575
Podstawowe zasady debugowania ............................................................................... 575
Taksonomia błędów ................................................................................................... 576
Unikanie błędów ........................................................................................................ 576
Przewidywanie błędów ................................................................................................ 577
Rejestrowanie błędów ........................................................................................... 577
Rejestrowanie śladu ............................................................................................. 578
Asercje ................................................................................................................ 589
Spis treści
13
Techniki debugowania ................................................................................................ 590
Reprodukcja błędów .............................................................................................. 591
Debugowanie błędów powtarzalnych ....................................................................... 592
Debugowanie błędów niemożliwych do powtórzenia ................................................. 592
Debugowanie błędów pamięci ................................................................................ 593
Debugowanie programów wielowątkowych ............................................................... 597
Przykład debugowania: cytowanie artykułów ............................................................ 598
Wnioski z przykładu ArticleCitations ........................................................................ 609
Podsumowanie .......................................................................................................... 609
Rozdział 21. W głąb STL: kontenery i iteratory .....................................................................................611
Przegląd kontenerów .................................................................................................. 612
Wymagania co do elementów ................................................................................. 612
Wyjątki i kontrola błędów ....................................................................................... 614
Iteratory ............................................................................................................... 614
Kontenery sekwencyjne .............................................................................................. 616
Wektor ................................................................................................................. 616
Specjalizowana implementacja vector bool .......................................................... 634
Kontener deque .................................................................................................... 635
Kontener list ........................................................................................................ 636
Adaptery kontenerów .................................................................................................. 640
Adapter queue ...................................................................................................... 640
Adapter priority_queue .......................................................................................... 643
Adapter stack ....................................................................................................... 646
Kontenery asocjacyjne ................................................................................................ 647
Klasa narzędziowa pair .......................................................................................... 647
Kontener map ...................................................................................................... 648
Kontener multimap ............................................................................................... 657
Kontener set ........................................................................................................ 661
Kontener multiset ................................................................................................. 663
Inne kontenery ........................................................................................................... 663
Tablice jako kontenery STL .................................................................................... 663
string jako kontener STL ........................................................................................ 664
Strumienie jako kontenery STL ............................................................................... 665
Kontener bitset .................................................................................................... 665
Podsumowanie .......................................................................................................... 670
Część V Użycie bibliotek i wzorców ................................................................................671
Rozdział 22. Poznajemy algorytmy STL oraz obiekty funkcyjne ....................................................... 673
Przegląd algorytmów ................................................................................................... 674
Algorytmy find() oraz find_if() .................................................................................. 674
Algorytm accumulate() ........................................................................................... 677
Obiekty funkcyjne ....................................................................................................... 678
Obiekty funkcji arytmetycznych ............................................................................... 678
Obiekty funkcji porównań ....................................................................................... 679
Obiekty funkcji logicznych ...................................................................................... 680
Adaptery obiektów funkcyjnych ............................................................................... 681
Tworzenie własnych obiektów funkcyjnych ............................................................... 685
14
C++. Zaawansowane programowanie
Szczegóły budowy algorytmów ..................................................................................... 686
Algorytmy użytkowe ............................................................................................... 686
Algorytmy niemodyfikujące ..................................................................................... 687
Algorytmy modyfikujące ......................................................................................... 693
Algorytmy sortujące ............................................................................................... 698
Algorytmy dla zbiorów ............................................................................................ 701
Przykład użycia algorytmów i obiektów funkcyjnych: kontrola list wyborców ...................... 702
Problem kontroli rejestrów wyborców ...................................................................... 703
Funkcja auditVoterRolls() ....................................................................................... 703
Funkcja getDuplicates() ......................................................................................... 704
Funktor RemoveNames ......................................................................................... 705
Funktor NameInList ............................................................................................... 706
Testowanie funkcji auditVoterRolls() ....................................................................... 707
Podsumowanie .......................................................................................................... 708
Rozdział 23. Dostosowywanie i rozszerzanie STL ............................................................................. 709
Alokatory ................................................................................................................... 710
Adaptery iteratorów .................................................................................................... 710
Iteratory działające wstecz ..................................................................................... 710
Iteratory strumienia ............................................................................................... 712
Iteratory wstawiające ............................................................................................ 712
Rozszerzanie STL ....................................................................................................... 714
Po co rozszerzamy STL? ........................................................................................ 715
Tworzenie algorytmów STL ..................................................................................... 715
Tworzenie kontenera STL ....................................................................................... 717
Podsumowanie .......................................................................................................... 747
Rozdział 24. Rzecz o obiektach rozproszonych ................................................................................. 749
Zalety programowania rozproszonego .......................................................................... 749
Rozpraszanie w celu zwiększenia skalowalności ...................................................... 749
Rozpraszanie w celu zwiększenia niezawodności ..................................................... 750
Rozpraszanie w celu centralizacji ........................................................................... 750
Rozpraszanie treści ............................................................................................... 751
Przetwarzanie rozproszone a sieciowe .................................................................... 751
Obiekty rozproszone ................................................................................................... 752
Serializacja i szeregowanie .................................................................................... 752
Zdalne wywoływanie procedur ................................................................................ 756
CORBA ...................................................................................................................... 758
Język definicji interfejsu ......................................................................................... 758
Implementacja klasy ............................................................................................. 761
Wykorzystanie obiektów ........................................................................................ 762
XML .......................................................................................................................... 766
Szybki kurs XML ................................................................................................... 766
XML jako technologia obiektów rozproszonych ......................................................... 768
Generowanie i analizowanie XML w C++ ................................................................. 769
Kontrola poprawności XML .................................................................................... 777
Tworzenie obiektów rozproszonych z użyciem XML ................................................... 779
SOAP (ang. Simple Object Access Protocol) ............................................................ 782
Podsumowanie .......................................................................................................... 784
Spis treści
15
Rozdział 25. Korzystanie z technik i bibliotek ..................................................................................... 785
Nigdy nie pamiętam, jak… .......................................................................................... 786
…utworzyć klasę .................................................................................................. 786
…dziedziczyć po istniejącej klasie .......................................................................... 787
…zgłosić i przechwycić wyjątek .............................................................................. 788
…odczytać z pliku ................................................................................................. 789
…zapisać do pliku ................................................................................................ 789
…utworzyć szablon klasy ....................................................................................... 790
Musi istnieć lepszy sposób ......................................................................................... 792
Inteligentne wskaźniki ze zliczaniem referencji ........................................................ 792
Podwójne rozsyłanie .............................................................................................. 797
Klasy domieszkowe ............................................................................................... 803
Biblioteki obiektowe ................................................................................................... 806
Wykorzystywanie bibliotek ..................................................................................... 806
Paradygmat model-widok-kontroler ......................................................................... 807
Podsumowanie .......................................................................................................... 808
Rozdział 26. Wykorzystanie wzorców projektowych ....................................................................... 809
Wzorzec singleton ...................................................................................................... 810
Przykład: mechanizm dziennika .............................................................................. 810
Implementacja klasy singleton ............................................................................... 810
Wykorzystanie klasy singleton ................................................................................ 815
Wzorzec factory .......................................................................................................... 816
Przykład: symulacja fabryki samochodów ................................................................ 816
Implementacja klasy factory .................................................................................. 818
Wykorzystanie wzorca factory ................................................................................. 820
Inne zastosowania wzorca factory .......................................................................... 822
Wzorzec proxy ............................................................................................................ 822
Przykład: ukrywanie problemów z połączeniem sieciowym ........................................ 822
Implementacja klasy proxy ..................................................................................... 823
Wykorzystanie klasy proxy ..................................................................................... 824
Wzorzec adapter ........................................................................................................ 824
Przykład: adaptacja biblioteki XML ......................................................................... 824
Implementacja adaptera ........................................................................................ 825
Wykorzystanie klasy adaptera ................................................................................ 828
Wzorzec decorator ..................................................................................................... 829
Przykład: definiowanie stylów na stronach WWW ..................................................... 829
Implementacja klasy decorator .............................................................................. 830
Wykorzystanie klasy decorator ............................................................................... 831
Wzorzec chain of responsibility ................................................................................... 832
Przykład: obsługa zdarzeń ...................................................................................... 833
Implementacja łańcucha odpowiedzialności ............................................................ 833
Wykorzystanie łańcucha odpowiedzialności ............................................................. 834
Wzorzec observer ....................................................................................................... 834
Przykład: obsługa zdarzeń ...................................................................................... 835
Implementacja wzorca observer ............................................................................. 835
Wykorzystanie wzorca observer .............................................................................. 836
Podsumowanie .......................................................................................................... 837
16
C++. Zaawansowane programowanie
Dodatki ..............................................................................................................................839
Dodatek A Rozmowy kwalifikacyjne z C++ .......................................................................................... 841
Rozdział 1. „Skrócony kurs C++” ................................................................................. 841
Rozdział 2. „Tworzenie profesjonalnych programów w C++” ........................................... 842
Rozdział 3. „Projektowanie obiektowe” ........................................................................ 843
Rozdział 4. „Użycie bibliotek i wzorców” ....................................................................... 844
Rozdział 5. „Projektowanie z myślą o ponownym użyciu” ............................................... 845
Rozdział 6. „Użycie metod inżynierii oprogramowania” .................................................. 846
Rozdział 7. „Styl kodowania” ...................................................................................... 847
Rozdziały 8. i 9. Klasy i obiekty ....
Pobierz darmowy fragment (pdf)
Gdzie kupić całą publikację:
Opinie na temat publikacji:
Inne popularne pozycje z tej kategorii:
Czytaj również:
Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką :