Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00588 013431 24107299 na godz. na dobę w sumie
wyszukaj dokładnie | pobierz wtyczkę
C++. Zaawansowane programowanie - książka
C++. Zaawansowane programowanie - książka
Autor: , Liczba stron: 912
Wydawca: Helion Język publikacji: polski
ISBN: 83-7361-998-4 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> c++ - programowanie
Porównaj ceny (książka, ebook, audiobook).
Czytaj online.
Komentuj

Poznaj możliwości i mechanizmy C++ stosowane przez profesjonalistów

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.

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ę:

C++. Zaawansowane programowanie
Autor: ,
Sklep
Format
Cena
Helion.pl Helion.pl
książka
97,00 zł
Idź do sklepu »

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ą: