Programowanie w systemie Windows. Wydanie IV

Wybierając system Windows jako docelową platformę rozwijanych aplikacji, programiści na całym świecie sugerują się najczęściej jego dużą funkcjonalnością i wymogami biznesowymi. System ten jest bowiem zgodny z wieloma kluczowymi standardami. Obsługuje między innymi biblioteki standardowe języków C i C+ oraz uwzględnia wiele otwartych standardów współdziałania.

Dlatego gniazda systemu Windows są standardowym interfejsem programowania rozwiązań sieciowych z dostępem do TCP/IP i innych protokołów sieciowych. W dodatku każda nowa wersja tego systemu jest coraz bardziej zintegrowana z dodatkowymi technologiami z obszaru multimediów, sieci bezprzewodowych, usług Web Service, platformy .NET i usługi plug-and-play. Niewątpliwym atutem Windows jest także zawsze uważany za stabilny, a jednak ciągle wzbogacany o ważne dodatki interfejs API.

Jeśli zatem szukasz kompletnego, rzetelnego i aktualnego podręcznika do nauki programowania za pomocą interfejsu Windows API, właśnie go znalazłeś! Książka ta w praktyczny sposób przedstawia wszystkie mechanizmy systemu Windows potrzebne programistom, pokazując, w jaki sposób działają funkcje tego systemu i jak wchodzą w interakcje z aplikacjami.

Skoncentrowano się tu na podstawowych usługach systemu, w tym na systemie plików, zarządzaniu procesami i wątkami, komunikacji między procesami, programowaniu sieciowym i synchronizacji. Autor tej książki nie zamierza jednak obciążać Cię zbędną teorią i nieistotnymi szczegółami. Podaje Ci wiedzę opartą na prawdziwych przykładach, dzięki czemu szybko i sprawnie opanujesz poruszane tu zagadnienia. Wiadomości, które tu znajdziesz, pozwolą Ci zrozumieć interfejs Windows API w takim stopniu, byś zdobył solidne podstawy do rozwijania programów na platformę .NET Microsoftu.

W książce znajdziesz omówienie między innymi takich kwestii, jak:

• wprowadzenie do rodziny systemów operacyjnych Windows
• wykorzystanie paralelizmu i maksymalizowanie wydajności w systemach wielordzeniowych
• używanie 64-bitowej przestrzeni adresowej oraz zapewnianie przenośności między środowiskami 64- i 32-bitowymi
• zagadnienia związane z systemami plików, operacjami wejścia-wyjścia w konsoli, blokowaniem dostępu do plików i zarządzaniem katalogami
• wprowadzenie do obsługi wyjątków w systemie Windows, w tym do mechanizmu SEH
• zarządzanie i synchronizacja procesów systemu Windows
• zarządzanie pamięcią i biblioteki DLL
• szczegółowe omówienie synchronizacji wątków systemu Windows, pul wątków i wydajności
• przekształcanie aplikacji serwerowych na usługi systemu Windows
• zapewnianie przenośności kodu źródłowego oraz współdziałania aplikacji z systemów Windows, Linux i UNIX
• zabezpieczanie obiektów w systemie Windows
• poprawiające wydajność funkcje interfejsu Windows API — blokady SRW i zmienne warunkowe

Rozdziały:

Rozdział 1. Wprowadzenie do systemu Windows (35)

• Podstawy systemów operacyjnych (36)
• Ewolucja systemu Windows (37)
• Wersje systemu Windows (37)
• Pozycja systemu Windows na rynku (40)
• System Windows, standardy i systemy o otwartym dostępie do kodu źródłowego (41)
• Podstawy systemu Windows (43)
• Przenośność 32- i 64-bitowego kodu źródłowego (46)
• Biblioteka standardowa języka C - kiedy korzystać z niej do przetwarzania plików? (47)
• Co jest potrzebne do korzystania z tej książki? (48)
• Przykład - proste sekwencyjne kopiowanie pliku (50)
• Podsumowanie (58)
• Ćwiczenia (61)

Rozdział 2. Korzystanie z systemu plików i znakowych operacji wejścia-wyjścia w systemie Windows (63)

• Systemy plików w systemie Windows (64)
• Reguły tworzenia nazw plików (65)
• Otwieranie, wczytywanie, zapisywanie i zamykanie plików (66)
• Przerywnik - Unicode i znaki ogólne (74)
• Strategie związane z kodowaniem Unicode (77)
• Przykład - przetwarzanie błędów (78)
• Urządzenia standardowe (81)
• Przykład - kopiowanie wielu plików do standardowego wyjścia (82)
• Przykład - proste szyfrowanie pliku (85)
• Zarządzanie plikami i katalogami (88)
• Operacje wejścia-wyjścia konsoli (94)
• Przykład - wyświetlanie danych i instrukcji (96)
• Przykład - wyświetlanie bieżącego katalogu (99)
• Podsumowanie (100)
• Ćwiczenia (101)

Rozdział 3. Zaawansowane przetwarzanie plików i katalogów oraz rejestr (103)

• 64-bitowy system plików (104)
• Wskaźniki do plików (104)
• Pobieranie rozmiaru plików (109)
• Przykład - bezpośrednie aktualizowanie rekordów (111)
• Atrybuty plików i przetwarzanie katalogów (115)
• Przykład - wyświetlanie atrybutów plików (121)
• Przykład - ustawianie znaczników czasu dla plików (125)
• Strategie przetwarzania plików (126)
• Blokowanie dostępu do plików (128)
• Rejestr (134)
• Zarządzanie rejestrem (137)
• Przykład - wyświetlanie kluczy i zawartości rejestru (141)
• Podsumowanie (145)
• Ćwiczenia (146)

Rozdział 4. Obsługa wyjątków (149)

• Wyjątki i procedury do ich obsługi (150)
• Wyjątki zmiennoprzecinkowe (157)
• Błędy i wyjątki (159)
• Przykład - traktowanie błędów jak wyjątków (161)
• Procedury obsługi zakończenia (163)
• Przykład - stosowanie procedur obsługi zakończenia do poprawy jakości programów (167)
• Przykład - stosowanie funkcji filtrującej (170)
• Procedury sterujące konsoli (175)
• Przykład - procedura sterująca konsoli (176)
• Wektorowa obsługa wyjątków (178)
• Podsumowanie (180)
• Ćwiczenia (181)

Rozdział 5. Zarządzanie pamięcią, pliki odwzorowane w pamięci i biblioteki DLL (183)

• Architektura zarządzania pamięcią w systemie Windows (184)
• Sterty (187)
• Zarządzanie pamięcią na stercie (191)
• Przykład - sortowanie plików za pomocą binarnego drzewa wyszukiwań (198)


• Pliki odwzorowane w pamięci (203)
• Przykład - sekwencyjne przetwarzanie pliku za pomocą plików odwzorowanych (212)


• Przykład - sortowanie pliku odwzorowanego w pamięci (215)
• Przykład - stosowanie wskaźników z bazą (218)
• Biblioteki DLL (224)
• Przykład - dołączanie w czasie wykonywania programu funkcji do konwersji plików (231)
• Punkt wejścia do biblioteki DLL (232)
• Zarządzanie wersjami bibliotek DLL (234)
• Podsumowanie (236)
• Ćwiczenia (237)

Rozdział 6. Zarządzanie procesem (241)

• Procesy i wątki w systemie Windows (241)
• Tworzenie procesu (244)
• Dane identyfikacyjne procesów (251)
• Powielanie uchwytów (252)
• Wychodzenie z procesu i kończenie jego działania (254)
• Oczekiwanie na zakończenie działania procesu (256)
• Bloki i łańcuchy znaków środowiska (258)
• Przykład - równoległe wyszukiwanie wzorca (260)
• Procesy w środowisku wieloprocesorowym (264)
• Czas wykonywania procesu (265)
• Przykład - czas wykonywania procesu (265)
• Generowanie zdarzeń sterujących konsoli (267)
• Przykład - proste zarządzanie zadaniem (268)
• Przykład - korzystanie z obiektów zadań (279)
• Podsumowanie (283)
• Ćwiczenia (284)

Rozdział 7. Wątki i szeregowanie (287)

• Wprowadzenie do wątków (287)
• Podstawowe informacje o wątkach (290)
• Zarządzanie wątkami (291)
• Stosowanie biblioteki języka C w wątkach (296)
• Przykład - wielowątkowe wyszukiwanie wzorca (298)
• Wpływ na wydajność (301)
• Wątki główne i robocze oraz inne modele działania wątków (303)
• Przykład - sortowanie przez scalanie z wykorzystaniem wielu procesorów (304)


• Wprowadzenie do paralelizmu w programach (311)
• Pamięć TLS (312)
• Priorytety oraz szeregowanie procesów i wątków (314)
• Stany wątków (317)
• Pułapki i często popełniane błędy (319)
• Oczekiwanie z pomiarem czasu (321)
• Włókna (322)
• Podsumowanie (325)
• Ćwiczenia (326)

Rozdział 8. Synchronizowanie wątków (329)

• Dlaczego trzeba synchronizować wątki? (330)
• Obiekty synchronizacji wątków (339)
• Obiekty CRITICAL_SECTION (340)
• Obiekty CRITICAL_SECTION do zabezpieczania współużytkowanych zmiennych (343)


• Przykład - prosty system z producentem i konsumentem (345)
• Muteksy (351)
• Semafory (358)
• Zdarzenia (361)
• Przykład - system z producentem i konsumentem (364)
• Więcej wskazówek na temat muteksów i obiektów CRITICAL_SECTION (369)


• Inne funkcje Interlocked (371)
• Wydajność przy zarządzaniu pamięcią (373)
• Podsumowanie (374)
• Ćwiczenia (375)

Rozdział 9. Blokowanie, wydajność i dodatki w systemach NT6 (377)

• Wpływ synchronizacji na wydajność (378)
• Program do badania wydajności (383)
• Dopracowywanie wydajności systemów wieloprocesorowych za pomocą liczby powtórzeń pętli obiektów CS (384)
• Blokady SRW w systemach NT6 (387)
• Zmniejszanie rywalizacji za pomocą puli wątków (390)
• Porty kończenia operacji wejścia-wyjścia (393)
• Pule wątków z systemów NT6 (394)
• Podsumowanie - wydajność blokowania (403)
• Paralelizm po raz wtóry (404)
• Koligacja procesora (409)
• Wskazówki i pułapki z obszaru wydajności (411)
• Podsumowanie (413)
• Ćwiczenia (414)

Rozdział 10. Zaawansowana synchronizacja wątków (417)

• Model zmiennej warunkowej i właściwości związane z bezpieczeństwem (418)
• Stosowanie funkcji SignalObjectAndWait (426)
• Przykład - obiekt bariery z progiem (428)
• Obiekt kolejki (432)
• Przykład - wykorzystanie kolejek w wieloetapowym potoku (436)
• Zmienne warunkowe z systemów Windows NT6 (446)
• Asynchroniczne wywołania procedur (451)
• Kolejkowanie asynchronicznych wywołań procedur (452)
• Oczekiwanie z obsługą alertów (454)
• Bezpieczne anulowanie wątków (456)
• Wątki Pthreads i przenośność aplikacji (457)
• Stosy wątków i liczba wątków (457)
• Wskazówki z obszaru projektowania, diagnozowania i testowania (458)
• Poza interfejs Windows API (461)
• Podsumowanie (462)
• Ćwiczenia (463)

Rozdział 11. Komunikacja między procesami (467)

• Potoki anonimowe (468)
• Przykład - przekierowywanie wejścia-wyjścia za pomocą potoku anonimowego (469)


• Potoki nazwane (472)
• Funkcje do obsługi transakcji z wykorzystaniem potoku nazwanego (479)
• Przykład - system klient-serwer do przetwarzania wiersza poleceń (483)
• Komentarze na temat programu klient-serwer do przetwarzania wiersza poleceń (489)


• Szczeliny pocztowe (491)
• Tworzenie i nazywanie potoków oraz szczelin pocztowych i nawiązywanie połączeń z nimi (496)
• Przykład - serwer możliwy do znalezienia przez klienty (496)
• Podsumowanie (499)
• Ćwiczenia (500)

Rozdział 12. Programowanie sieciowe z wykorzystaniem gniazd systemu Windows (503)

• Gniazda systemu Windows (504)
• Funkcje do obsługi gniazd serwera (507)
• Funkcje do obsługi gniazd klienta (513)
• Porównanie potoków nazwanych i gniazd (515)
• Przykład - funkcja do odbierania komunikatów w gnieździe (516)
• Przykład - klient oparty na gniazdach (517)
• Przykład - oparty na gniazdach serwer z nowymi mechanizmami (519)
• Serwery wewnątrzprocesowe (529)
• Komunikaty oparte na wierszach, punkty wejścia bibliotek DLL i pamięć TLS (531)
• Przykład - bezpieczna ze względu na wątki biblioteka DLL do obsługi komunikatów w gniazdach (533)
• Przykład - inna strategia tworzenia bibliotek DLL bezpiecznych ze względu na wątki (538)
• Datagramy (541)
• Gniazda Berkeley a gniazda systemu Windows (543)
• Operacje nakładanego wejścia-wyjścia oparte na gniazdach systemu Windows (544)


• Dodatkowe funkcje gniazd systemu Windows (544)
• Podsumowanie (545)
• Ćwiczenia (546)

Rozdział 13. Usługi systemu Windows (549)

• Tworzenie usług systemu Windows - przegląd (550)
• Funkcja main() (551)
• Funkcje ServiceMain() (552)
• Procedura sterująca usługi (557)
• Rejestrowanie zdarzeń (558)
• Przykład - nakładka na usługi (558)
• Zarządzanie usługami systemu Windows (565)
• Podsumowanie - działanie usług i zarządzanie nimi (569)
• Przykład - powłoka do sterowania usługą (569)
• Współużytkowanie obiektów jądra przy użyciu usługi (574)
• Uwagi na temat diagnozowania usług (575)
• Podsumowanie (576)
• Ćwiczenia (577)

Rozdział 14. Asynchroniczne operacje wejścia-wyjścia i IOCP (579)

• Przegląd asynchronicznych operacji wejścia-wyjścia w systemie Windows (580)


• Operacje nakładanego wejścia-wyjścia (581)
• Przykład - synchronizacja z wykorzystaniem uchwytu pliku (586)
• Przykład - przekształcanie pliku za pomocą operacji nakładanego wejścia-wyjścia i wielu buforów (587)
• Wzbogacone operacje wejścia-wyjścia z procedurami zakończenia (591)
• Przykład - przekształcanie plików za pomocą wzbogaconych operacji wejścia-wyjścia (597)
• Asynchroniczne operacje wejścia-wyjścia z wykorzystaniem wątków (600)
• Zegary oczekujące (602)
• Przykład - korzystanie z zegarów oczekujących (605)
• Mechanizm IOCP (607)
• Przykład - serwer oparty na mechanizmie IOCP (612)
• Podsumowanie (619)
• Ćwiczenia (620)

Rozdział 15. Zabezpieczanie obiektów systemu Windows (623)

• Atrybuty zabezpieczeń (623)
• Przegląd zabezpieczeń - deskryptor zabezpieczeń (624)
• Flagi kontrolne deskryptora zabezpieczeń (628)
• Identyfikatory zabezpieczeń (628)
• Zarządzanie listami ACL (630)
• Przykład - uprawnienia w stylu UNIX-a do plików NTFS (632)
• Przykład - inicjowanie atrybutów zabezpieczeń (636)
• Wczytywanie i modyfikowanie deskryptorów zabezpieczeń (641)
• Przykład - odczytywanie uprawnień do pliku (643)
• Przykład - modyfikowanie uprawnień do plików (645)
• Zabezpieczanie obiektów jądra i komunikacji (645)
• Przykład - zabezpieczanie procesu i jego wątków (648)
• Przegląd dodatkowych mechanizmów zabezpieczeń (648)
• Podsumowanie (650)
• Ćwiczenia (651)

Dodatek A: Używanie przykładowych programów (655)

• Układ plików w pakiecie Przykłady (656)

Dodatek B: Przenośność kodu źródłowego - Windows, UNIX i Linux (659)

• Strategie tworzenia przenośnego kodu źródłowego (660)
• Usługi systemu Windows dla systemu UNIX (660)
• Przenośność kodu źródłowego z funkcjami systemu Windows (661)
• Rozdziały 2. i 3. - zarządzanie plikami i katalogami (667)
• Rozdział 4. - obsługa wyjątków (672)
• Rozdział 5. - zarządzanie pamięcią, pliki odwzorowane w pamięci i biblioteki DLL (674)
• Rozdział 6. - zarządzanie procesem (675)
• Rozdział 7. - wątki i szeregowanie (677)
• Rozdziały od 8. do 10. - synchronizowanie wątków (679)
• Rozdział 11. - komunikacja między procesami (681)
• Rozdział 14. - asynchroniczne operacje wejścia-wyjścia (684)
• Rozdział 15. - zabezpieczanie obiektów systemu Windows (685)

Dodatek C: Wyniki pomiarów wydajności (687)

• Konfiguracje testowe (687)
• Pomiary wydajności (690)
• Przeprowadzanie testów (703)