Czytając niniejszą książkę Czytelnik dowie się jak:

• Zaprojektować i efektywnie zaimplementować modele obiektowe przy wykorzystaniu UML
• Zaprojektować obiektowe algorytmy sortowania
• Wykorzystać kontenery i iteratory biblioteki standardowej
• Wybrać najlepszą metodę przeszukiwania
• Poznać najlepsze techniki mieszające
• Tworzyć dynamiczne struktury danych za pomocą rekursji
• Projektować obiektowe bazy danych
• Odkryć związki pomiędzy C++ i CORBA, COM i Javą

Brak CD, z przykładami w tym egzemplarzu, ale nie umniejsza to wartości książki, która obecnie jest bardzo trudna do kupienia.

ZAPRASZAM DO POZOSTAŁYCH MOICH AUKCJI KSIĄŻEK INFORMATYCZNYCH!

ODBIÓR OSOBISTY: WROCŁAW, okolice Galerii Dominikańskiej lub Muchobór

SPIS TREŚCI:

Wprowadzenie (21)
Część I. Programowanie zorientowane obiektowo (25)
Rozdział 1. Analiza i planowanie programowania obiektowego (27)

• Budowanie modeli (28)
• Konstrukcja programu - język modelowania (28)
• Konstrukcja programowania - proces (30)
• Wizja projektu (32)
• Wymagania (32)
  • Sposób używania (32)
  • Analiza aplikacji (42)
  • Analiza systemu (42)
  • Planowanie dokumentacji (43)
  • Wizualizacja (43)
  • Określenia (44)
• Projektowanie (44)
  • Co to są klasy? (45)
  • Przekształcenia (47)
  • Model statyczny (48)
  • Model dynamiczny (56)
• Podsumowanie (59)

Rozdział 2. Implementacja zaprojektowanych klas w C++ (61)

• Przekształcanie schematów klas w C++ (61)
  • Klasy standardowe (62)
  • Klasy wzorcowe (63)
  • Klasy narzędzi (64)
  • Powiązania (64)
  • Gromadzenie (70)
  • Uogólnienie (71)
• Przekształcanie schematów współdziałania w C++ (73)
  • Implementacja schematu współpracy i schematu sekwencyjnego w C++ (74)
• Implementacja schematów zmiany stanów w C++ (79)
• Implementacja schematów działania w C++ (82)
• Podsumowanie (85)

Rozdział 3. Dziedziczenie, polimorfizm oraz wielokrotne wykorzystanie kodu (87)

• Korzyści z dziedziczenia (88)
• Listy powiązane zorientowane obiektowo (88)
  • Projektowanie listy powiązanej (89)
  • Implementacja listy powiązanej (90)
• Klasy abstrakcyjne (95)
  • Zastępowanie metod wirtualnych (99)
• Destruktory wirtualne (100)
• Polimorfizm i przeciążanie metod (100)
• Zarządzanie pamięcią (104)
• Problem przeciążania innych operatorów (108)
  • Operator przypisania (108)
  • Przeciążanie operatora inkrementacji (111)
  • Wirtualne konstruktory kopiowania (114)
• Wielokrotne dziedziczenie (115)
  • Problemy wielokrotnego dziedziczenia (116)
  • Wielokrotne dziedziczenie kontra zawieranie (120)
• Podsumowanie (122)

Część II. Zagadnienia implementacyjne (123)
Rozdział 4. Zarządzanie pamięcią (125)

• Wskaźniki i zarządzanie pamięcią (126)
  • Straty pamięci (129)
  • Alokacja tablic (129)
  • Nieprawidłowe wartości wskaźników (131)
  • Stałe wskaźniki (132)
  • Stałe wskaźniki i stałe funkcje (132)
  • Przekazywanie przez referencję (133)
  • Przekazywanie stałego wskaźnika (133)
  • Nie zwracaj referencji do nieistniejącego obiektu (133)
  • Wskaźnik, wskaźnik, gdzie jest wskaźnik? (136)
• Wskaźniki i wyjątki (137)
  • Używanie automatycznych wskaźników (141)
  • Zliczanie odwołań (146)
• Podsumowanie (157)

Rozdział 5. Korzystanie z szablonów (159)

• Microsoft Foundation Classes (159)
  • Rozpoczęcie pracy (160)
  • Inne kreatory (163)
• Architektura aplikacji (163)
  • Wielowątkowość (164)
  • Współdziałanie kontra wywłaszczanie wielowątkowe (165)
• Wywłaszczenie wielowątkowe (165)
• Przykład (166)
  • Tworzenie wątków (167)
• Klasy narzędzi (185)
  • Klasa CString (186)
  • Klasy czasowe (186)
• Dokumenty i widoki (187)
  • Widoki (188)
• Podsumowanie (200)

Rozdział 6. Biblioteka standardowych szablonów klas kontenerów (201)

• Definiowanie i ukonkretnianie szablonów (201)
  • Definiowanie i ukonkretnianie szablonów funkcji (202)
  • Definiowanie i ukonkretnianie szablonów klas (202)
• Kontenery sekwencyjne (204)
  • Kontener-wektor (204)
  • Kontener-lista (220)
  • Kontener-kolejka dwukierunkowa (230)
• Stosy (231)
• Kolejki (235)
  • Kolejki priorytetowe (237)
• Kontenery skojarzeniowe (238)
  • Kontener-mapa (238)
  • Kontener-multimapa (250)
  • Kontener-zbiór (252)
  • Kontener-multizbiór (252)
• Względy efektywności (252)
• Korzystanie ze standardowej biblioteki C++ (254)
• Projektowanie typów elementów (255)
• Podsumowanie (256)

Rozdział 7. Algorytmy i iteratory biblioteki standardowych szablonów (257)

• Klasy iteratorów (257)
  • Miejsce elementu w kontenerze (257)
  • Typy iteratorów kontenera (258)
  • Klasy bazowe iteratora (259)
  • Iteratory wejścia (260)
  • Iteratory wyjścia (261)
  • Iteratory przejścia w przód (261)
  • Iteratory dwukierunkowe (261)
  • Iteratory bezpośredniego dostępu (262)
  • Standardowe klasy iteratorów (264)
• Obiekty funkcyjne (266)
  • Predykaty (267)
  • Funkcje arytmetyczne (268)
• Klasy algorytmów (269)
  • Algorytmy nie zmieniające kolejności elementów w sekwencji (269)
  • Algorytmy zmieniające kolejność elementów w sekwencji (279)
  • Sortowanie i inne pokrewne operacje (293)
  • Składnia standardowych funkcji (313)
• Podsumowanie (320)

Rozdział 8. Korzystanie z przestrzeni nazw (321)

• Funkcje i klasy są określane przez nazwę (322)
• Tworzenie przestrzeni nazw (325)
  • Deklarowanie i definiowanie typów (326)
  • Definiowanie funkcji poza przestrzenią nazw (326)
  • Dodawanie nowych składowych (327)
  • Zagnieżdżanie przestrzeni nazw (328)
• Używanie przestrzeni nazw (328)
• Słowo kluczowe using (331)
  • Dyrektywa using (331)
  • Deklaracja using (333)
• Alias przestrzeni nazw (334)
• Nienazwana przestrzeń nazw (335)
• Standardowa przestrzeń nazw std (336)
• Podsumowanie (337)

Rozdział 9. Zarządzanie typami obiektów (339)

• Operator typeid () (339)
• Klasa type_info (340)
  • Konstruktor klasy type_info (340)
  • Operatory porównania (341)
  • Funkcja składowa name () (342)
  • Funkcja składowa before () (345)
  • Operator typeid () w konstruktorach i destruktorach (346)
  • Nadużywanie operatora typeid () (347)
• Dynamiczne rzutowanie typu obiektu (348)
  • Operator dynamic_cast () (348)
  • typeid () a dynamic_cast () (353)
• Inne operatory rzutowania (353)
  • Operator static_cast () (354)
  • Operator reinterpret_cast () (355)
  • Kiedy używać operatorów dynamic_cast (), static_cast () lub reinterpret_cast () (356)
  • Operator const_cast () (356)
• Stary a nowy styl rzutowania typów (358)
• Podsumowanie (359)

Rozdział 10. Optymalizacja wydajności aplikacji (361)

• Funkcje inline poza definicjami klas (361)
• Unikanie kodu implementacyjnego w rozproszonych plikach nagłówkowych (367)
• Analiza kosztów funkcji wirtualnych i wirtualnych klas bazowych (368)
  • Funkcje wirtualne (368)
  • Wirtualne klasy bazowe (372)
• Kompromisy związane z RTTI (375)
• Zarządzanie pamięcią na potrzeby obiektów tymczasowych (377)
• Podsumowanie (380)

Część III. Operowanie danymi (381)
Rozdział 11. Rekurencja i rekurencyjne struktury danych (383)

• Czym jest rekurencja z punktu widzenia programisty? (383)
  • Rekurencyjna definicja ciągu Fibonacciego (384)
  • Zakończenie rekurencji (386)
• Rekurencyjne struktury danych (386)
• Przetwarzanie rekurencyjnych struktur danych za pomocą funkcji rekurencyjnych (388)
• Rekurencja a iteracja, rekurencja końcowa (392)
  • Przekształcenie rekurencji końcowej w iterację (397)
• Rekurencja pośrednia (397)
• Rekurencja a stos (399)
• Śledzenie funkcji rekurencyjnych (400)
• Podsumowanie (400)

Rozdział 12. Efektywne metody sortowania (401)

• Analiza wydajności algorytmów (401)
  • Złożoność przeciętna, pesymistyczna i optymistyczna (403)
  • Stabilność sortowania (405)
  • Wykorzystanie pamięci przez algorytmy sortowania (406)
• Sortowanie bąbelkowe (406)
  • Analiza sortowania bąbelkowego (408)
• Sortowanie przez wstawianie (409)
  • Analiza sortowania przez wstawianie (411)
• Sortowanie przez wybieranie (412)
  • Analiza algorytmu sortowania przez wybieranie (414)
• Sortowanie szybkie (414)
  • Analiza sortowania szybkiego (417)
• Sortowanie przez łączenie (418)
  • Analiza sortowania przez łączenie (421)
• Sortowanie metodą Shella (422)
  • Analiza sortowania metodą Shella (423)
• Sortowanie stogowe (424)
  • Analiza sortowania stogowego (426)
• Wybór właściwej metody sortowania (426)
• Generowanie danych testowych (428)
• Podsumowanie (430)

Rozdział 13. Algorytmy przeszukiwania w C++ (431)

• Przeszukiwanie liniowe (431)
  • Analiza metody przeszukiwania liniowego (433)
  • Przeszukiwanie posortowanej tablicy (433)
• Dopasowywanie wzorca (436)
  • "Naiwny" algorytm dopasowywania wzorca (436)
  • Reprezentacje wzorców (437)
  • Dopasowywanie wzorca a konstrukcja automatów skończonych (438)
• Algorytmy grafowe (440)
  • Przeszukiwanie zstępujące grafu (441)
  • Przeszukiwanie grafu wszerz (443)
  • Przeszukiwanie "najpierw najlepszy" (444)
  • Implementacja grafów jako obiektów (445)
  • Strategie minimaksowe i wartościowanie gier (448)
  • Eliminacja zbędnych obliczeń poprzez a-b obcinanie (451)
  • Problem komiwojażera (452)
• Przeszukiwanie zewnętrzne (453)
  • Dostęp indeksowo-sekwencyjny (454)
  • Drzewa binarne (454)
  • Drzewa 2-3-4 (455)
• Podsumowanie (457)

Rozdział 14. Funkcje mieszające i analiza składniowa (459)

• Przeszukiwanie a funkcje mieszające (459)
• Wybór postaci funkcji mieszających (460)
  • Współczynnik zapełnienia a (463)
• Metody rozwiązywania konfliktów (463)
  • Szukanie liniowe (463)
  • Modyfikacje szukania liniowego (466)
  • Szukanie kwadratowe (467)
  • Metoda łańcuchowa (468)
• Analiza składniowa (473)
  • Rozbiór syntaktyczny wyrażeń arytmetycznych (474)
  • Drzewa rozbioru syntaktycznego (476)
  • Gramatyki bezkontekstowe (477)
  • Zastosowanie metody zstępującej do sprawdzania poprawności wyrażeń (478)
• Podsumowanie (479)

Część IV. Trwałość obiektów i techniki kryptograficzne (481)
Rozdział 15. Przechowywanie obiektów w plikach dyskowych (483)

• Tworzenie obiektów zachowywalnych (484)
• B-drzewa (491)
  • Zapis B-drzewa w pliku dyskowym (494)
• Współpraca z pamięcią operacyjną (495)
  • Określenie optymalnego rozmiaru strony i indeksu (495)
  • Określenie liczby stron przechowywanych jednocześnie w pamięci (496)
• Strony B-drzewa jako obiekty zachowywalne (496)
  • Jak to wszystko działa? (523)
  • Analiza kodu programu (525)
  • Wyszukiwanie (540)
• Podsumowanie (543)

Rozdział 16. Relacyjne bazy danych a trwałość obiektu (545)

• Podstawowe koncepcje relacyjnych baz danych (545)
• Architektura relacyjnych baz danych (548)
  • Ograniczenia i wymogi architektoniczne (549)
• SQL: Definiowanie i przepytywanie bazy danych (549)
  • Normalizacja bazy danych (550)
  • Złączenia tabel (551)
• Utrwalanie obiektu w relacyjnej bazie danych (552)
  • Wskaźniki a identyfikatory obiektów - swizzling (552)
  • Używanie obiektów BLOB (553)
• Ukrywanie szczegółów (553)
  • Bezpośrednia obsługa obiektów (554)
  • Użycie API bazy danych (554)
  • Dostęp do źródeł danych poprzez ODBC (554)
  • Wykorzystywanie Microsoft Foundation Classes (MFC) (557)
• Instrukcje SQL (571)
  • Ustawianie pozostałych właściwości bazy danych (571)
• Podsumowanie (571)

Rozdział 17. Obiektowe rozszerzenia relacyjnych baz danych (573)

• Obiekty w Oracle8 (574)
  • Typy obiektowe (574)
  • Odwołania do obiektów (576)
  • Kolekcje (577)
• Używanie procedur zewnętrznych stworzonych w C++ (579)
• Odwzorowywanie diagramów UML na obiektowo-relacyjne bazy danych (582)
  • Projektowanie bazy danych (583)
  • Generacja kodu w C++ (584)
  • Generowanie serwera (587)
• Analiza konkretnego przypadku: system zamawiania zakupów (591)
  • Opis systemu (592)

Rozdział 18. Obiektowo zorientowane systemy baz danych (595)

• Przegląd ODBMS (595)
• Standard ODMG (597)
• Program fakturujący w C++ (597)
• Utrwalanie obiektów w bazie danych (613)
  • Schematy baz danych oraz narzędzia do ich przechwytywania (615)
  • Kolekcje (617)
  • Iteratory (620)
  • Relacje (620)
• Bazy danych i transakcje (625)
• Techniczne aspekty ODBMS (639)
  • Architektura klient/serwer (639)
  • Przechowywanie danych oraz grupowanie obiektów (640)
  • Ziarnistość przesyłu danych (641)
  • Ziarnistość blokowania danych (642)
• Podsumowanie (643)

Rozdział 19. Szyfrowanie i bezpieczeństwo danych (645)

• Krótka historia kryptografii (645)
  • Rola National Bureau of Standards (646)
• Podstawowe pojęcia kryptograficzne (647)
  • Kodowanie (648)
  • Szyfrowanie (649)
  • Szyfr Vernama (651)
• Kryptografia z kluczem prywatnym (654)
  • Algorytmy szyfrowania z kluczem prywatnym (654)
  • Mechanizmy szyfrowania kluczem prywatnym (655)
  • KDC - Centra Dystrybucji Kluczy (658)
• Kryptografia z kluczami publicznymi (658)
  • Technika puzzli Ralpha Merkle (659)
  • Techniki kryptograficzne dla wielu użytkowników Diffiego-Hellmana (660)
  • Algorytm RSA (661)
• Pretty Good Privacy (PGP) (663)
  • Wybór liczb pierwszych w PGP (664)
  • Używanie liczb losowych w kryptografii (665)
  • Szyfrowanie plików przy użyciu PGP (665)
• Ograniczenia kryptografii (668)
• Ograniczenia prawne dotyczące kryptografii (670)
• Ataki kryptograficzne (671)
  • Atak bezpośredni (671)
  • Kryptoanaliza (671)
  • Atakowanie plików zaszyfrowanych przez PGP (672)
• Podpisy cyfrowe (673)
  • Public Key Cryptography Standard (PKCS) (674)
  • Digital Signature Standard (DSS) (674)
  • Niekwestionowane autorstwo (675)
• Komercyjne produkty kryptograficzne (675)
  • Bezpieczne przeglądarki WWW (675)
  • Bezpieczeństwo aplikacji-klienta poczty elektronicznej (677)
  • Produkty zabezpieczające komputer (678)
• Podsumowanie (681)

Część V. Podstawy rozproszonego przetwarzania danych (683)
Rozdział 20. CORBA (685)

• Specyfikacja i jej praktyczna realizacja (686)
  • Minimalne środowisko CORBA (687)
  • Struktura dla technologii obiektowej (688)
  • IIOP: Łącze pomiędzy obiektami (688)
  • Model komponentów (690)
• IDL: Kontrakt połączeniowy (690)
  • IDL a definicje klas C++ (692)
• ORB - Object Request Broker (693)
  • Czas życia obiektów (694)
  • Środowiska projektowe (694)
• Porównanie środowisk CORBA (695)
  • Możliwości współpracy poszczególnych wersji ORB (695)
• Tworzenie aplikacji klienta w C++ (697)
  • Generowanie pnia (697)
  • Połączenie z ORB (698)
  • Wywoływanie metod (699)
  • Kompletna aplikacja klienta w C++ (699)
• Tworzenie serwera w C++ (700)
  • Generowanie szkieletu (700)
  • Implementacja metod serwera (701)
  • Łączenie klasy serwera (702)
  • Ładowanie BOA w ORB (702)
• Klient Javy (704)
  • Generowanie pnia (704)
  • Kod inicjalizujący i wywołujący metody (705)
• Strategie testowania aplikacji (706)
  • Śledzenie przebiegu (706)
  • Monitor i rejestrowanie zdarzeń (706)
  • Obsługa wyjątków (706)
  • Zdalne śledzenie (707)
• Usługa nazw i współdziałanie (707)
  • Interoperable Object Reference (IOR) (708)
  • Konteksty nazw (708)
  • Zagadnienia współdziałania (709)
• Wydajność (710)
  • Gubienie pamięci w środowisku ORB (710)
  • Ziarnistość interfejsu (710)
  • Przekazywanie referencji obiektów do metod (711)
• Podsumowanie (711)

Rozdział 21. COM (713)

• Podstawy technologii COM (714)
  • Architektura COM (714)
  • Interfejsy COM (715)
  • Interfejs IUnknown (720)
  • Obiekty COM (723)
  • Biblioteki typów (726)
  • Inne technologie COM (727)
• Używanie obiektów COM w C++ (733)
  • Używanie prostych interfejsów (733)
  • Używanie inteligentnych wskaźników do interfejsów (734)
  • Używanie bibliotek typów (739)
• Tworzenie obiektów COM w C++ (742)
  • Dziedziczenie wielokrotne (742)
  • Klasy zagnieżdżone (745)
  • Używanie klas rozdzielonych (747)
• Podsumowanie (748)

Rozdział 22. Java i C++ (749)

• Podobieństwa pomiędzy C++ i Javą (749)
  • Komentarze (749)
  • Typy danych (750)
  • Operatory (752)
  • Wyrażenia kontrolujące przebieg programu (753)
• Różnice pomiędzy C++ i Javą (753)
  • Zarządzanie pamięcią (753)
  • Brak wskaźników (754)
  • Brak preprocesora (754)
  • Brak destruktorów (754)
  • Kwalifikatory dostępu (755)
  • Parametry metod (756)
  • Funkcje zewnętrzne (757)
  • Wyliczanie (757)
  • Łańcuchy (758)
  • Tablice (758)
• Obiektowe właściwości języka Java (759)
  • Klasy (759)
  • Dziedziczenie (765)
  • Dziedziczenie wielokrotne (767)
  • Obsługa wyjątków (768)
• Podsumowanie (769)