Visual C++ 2005. Od podstaw

Autor: Ivor Horton

Szczegóły książki w Helionie
Tytuł oryginału: Beginning Visual C++ 2005
ISBN: 978-83-246-0652-8
Cena: 127 zł
Oprawa: twarda
Format: B5
Data wydania: 2007.08.23
Liczba stron: 1224
Przykładowy rozdział: ftp://ftp.helion.pl/online/vcpppo/vcpppo-4.pdf
Kategoria: C++

Podręcznik dla początkujących programistów języka Visual C++ 2005

  • Jak pisać wydajne programy uruchamiane bezpośrednio w systemie Windows?
  • Jak błyskawicznie tworzyć aplikacje na platformę .NET?
  • Jakie techniki zastosować, by wygodnie zarządzać bazami danych?

C++ od czasu swego powstania cieszy się zasłużoną popularnością i nie mogło go zabraknąć wśród języków obsługiwanych przez środowisko Visual Studio, gdzie dostępne są dwie wersje tego języka. C++ ISO/ANSI pozwala pisać bardzo wydajne aplikacje, które można uruchamiać bezpośrednio w systemie Windows, podczas gdy C++/CLI to specyficzna dla Visual Studio odmiana umożliwiająca szybkie tworzenie rozbudowanych programów na platformę .NET.

Książka "Visual C++ 2005. Od podstaw" pozwoli Ci rozpocząć pracę z obiema wersjami języka Visual C++. Poznasz składnię wspólną dla obu odmian tego języka, a także specyficzne funkcje każdej z nich. Nauczysz się korzystać ze zintegrowanego środowiska programistycznego, które ułatwia pisanie, kompilowanie i diagnozowanie kodu. Dowiesz się też, jak obsługiwać i drukować dokumenty, zarządzać bazami danych czy przygotowywać własne biblioteki DLL.

  • Praca w zintegrowanym środowisku programistycznym
  • Składnia języków C++ ISO/ANSI i C++/CLI
  • Programowanie obiektowe w Visual C++
  • Diagnozowanie kodu
  • Pisanie aplikacji dla platformy .NET
  • Tworzenie oprogramowania dla systemu Windows
  • Przechowywanie i drukowanie dokumentów
  • Tworzenie własnych bibliotek DLL
  • Praca z bazami danych

Naucz się korzystać z najnowszych technologii i narzędzi
do tworzenia aplikacji dla systemu Windows.

Visual C++ 2005. Od podstaw -- spis treści

O autorze (19)

Wstęp (21)

Rozdział 1. Programowanie przy użyciu Visual C++ 2005 (27)

  • Środowisko programistyczne .NET (27)
  • Common Language Runtime (CLR) (28)
  • Pisanie programów w C++ (29)
  • Nauka programowania dla systemu Windows (30)
    • Nauka C++ (31)
    • Standardy C++ (32)
    • Aplikacje działające w trybie konsoli (32)
    • Koncepcje programowania w systemie Windows (33)
  • Czym jest zintegrowane środowisko programistyczne (35)
    • Składniki systemu (35)
  • Używanie IDE (37)
    • Opcje paska narzędzi (38)
    • Dokowalne paski narzędzi (39)
    • Dokumentacja (39)
    • Projekty i rozwiązania (40)
    • Ustawianie opcji w Visual C++ 2005 (54)
    • Tworzenie i uruchamianie programów dla Windowsa (55)
    • Tworzenie aplikacji Windows Forms (58)
  • Podsumowanie (61)

Rozdział 2. Dane, zmienne i działania arytmetyczne (63)

  • Struktura programu w C++ (64)
    • Funkcja main() (71)
    • Instrukcje programu (72)
    • Białe znaki (74)
    • Bloki instrukcji (75)
    • Programy konsolowe generowane automatycznie (75)
  • Definiowanie zmiennych (76)
    • Zasady nadawania nazw zmiennym (77)
    • Deklarowanie zmiennych (78)
    • Wartość początkowa zmiennej (79)
  • Podstawowe typy danych (80)
    • Zmienne całkowite (80)
    • Znakowe typy danych (81)
    • Modyfikatory typu integer (82)
    • Typ logiczny (83)
    • Typy zmiennopozycyjne (84)
    • Literały (85)
    • Definiowanie synonimów typów danych (86)
    • Zmienne o określonych zbiorach wartości (87)
    • Określanie typu stałych wyliczeniowych (88)
  • Podstawowe operacje wejścia-wyjścia (89)
    • Wprowadzanie danych z klawiatury (89)
    • Wysyłanie danych do wiersza poleceń (90)
    • Formatowanie wysyłanych danych (91)
    • Kodowanie znaków specjalnych (92)
  • Wykonywanie obliczeń w C++ (94)
    • Instrukcja przypisania (94)
    • Działania arytmetyczne (95)
    • Obliczanie reszty (100)
    • Modyfikowanie zmiennej (101)
    • Operatory inkrementacji i dekrementacji (102)
    • Kolejność wykonywania obliczeń (104)
  • Typy zmiennych i rzutowanie (106)
    • Zasady rzutowania operandów (106)
    • Rzutowanie w instrukcjach przypisania (107)
    • Rzutowanie jawne (108)
    • Rzutowanie w starym stylu (109)
    • Operatory bitowe (109)
  • Czas życia i zasięg zmiennych (116)
    • Zmienne automatyczne (116)
    • Pozycjonowanie deklaracji zmiennych (119)
    • Zmienne globalne (119)
    • Zmienne statyczne (123)
  • Przestrzenie nazw (123)
    • Deklarowanie przestrzeni nazw (125)
    • Wielokrotne deklaracje przestrzeni nazw (126)
  • Programowanie w C++/CLI (128)
    • Fundamentalne typy danych w C++/CLI (128)
    • Wysyłanie danych do wiersza poleceń w C++/CLI (133)
    • C++/CLI - formatowanie danych wyjściowych (133)
    • C++/CLI - wprowadzanie danych z klawiatury (136)
    • Bezpieczne rzutowanie (137)
    • Wyliczenia w C++/CLI (138)
  • Podsumowanie (141)
  • Ćwiczenia (142)

Rozdział 3. Decyzje i pętle (145)

  • Porównywanie wartości (145)
    • Instrukcja warunkowa if (147)
    • Zagnieżdżanie instrukcji warunkowych if (148)
    • Rozszerzona instrukcja warunkowa if (150)
    • Zagnieżdżanie instrukcji warunkowych if-else (152)
    • Operatory logiczne i wyrażenia (154)
    • Operator warunkowy (158)
    • Instrukcja switch (159)
    • Przejście bezwarunkowe (162)
  • Powtarzanie bloków instrukcji (163)
    • Czym jest pętla (163)
    • Różne sposoby użycia pętli for (165)
    • Pętla while (174)
    • Pętla do-while (176)
    • Zagnieżdżanie pętli (177)
  • Programowanie w C++/CLI (180)
    • Pętla for each (184)
  • Podsumowanie (187)
  • Ćwiczenia (187)

Rozdział 4. Tablice, łańcuchy znaków i wskaźniki (189)

  • Obsługa wielu wartości danych tego samego typu (190)
    • Tablice (190)
    • Deklarowanie tablic (191)
    • Inicjalizacja tablic (194)
    • Tablice znakowe oraz obsługa łańcuchów (196)
    • Tablice wielowymiarowe (200)
  • Pośredni dostęp do danych (203)
    • Czym jest wskaźnik (203)
    • Deklarowanie wskaźników (204)
    • Używanie wskaźników (205)
    • Inicjalizowanie wskaźników (207)
    • Operator sizeof (213)
    • Stałe wskaźniki oraz wskaźniki do stałych (215)
    • Wskaźniki i tablice (217)
  • Dynamiczne przydzielanie pamięci (224)
    • Pamięć wolna, czyli sterta (224)
    • Operatory new i delete (224)
    • Dynamiczne przydzielanie pamięci tablicom (225)
    • Dynamiczne przydzielanie pamięci tablicom wielowymiarowym (228)
  • Używanie referencji (229)
    • Czym jest referencja (229)
    • Deklarowanie i inicjalizowanie referencji (229)
  • Programowanie w C++/CLI (230)
    • Uchwyty śledzące (231)
    • Tablice CLR (233)
    • Łańcuchy (248)
    • Referencje śledzące (258)
    • Wskaźniki wewnętrzne (258)
  • Podsumowanie (261)
  • Ćwiczenia (263)

Rozdział 5. Wprowadzanie struktury do programu (265)

  • Zrozumieć funkcje (266)
    • Do czego potrzebne są funkcje (267)
    • Struktura funkcji (267)
    • Używanie funkcji (269)
  • Przekazywanie argumentów do funkcji (273)
    • Mechanizm przekazywania przez wartość (274)
    • Wskaźniki jako argumenty funkcji (275)
    • Przekazywanie tablic do funkcji (277)
    • Referencje jako argumenty funkcji (281)
    • Zastosowanie modyfikatora const (283)
    • Argumenty funkcji main() (285)
    • Akceptowanie zmiennej liczby argumentów funkcji (287)
  • Zwracanie wartości przez funkcję (289)
    • Zwracanie wskaźnika (289)
    • Zwracanie referencji (292)
    • Zmienna statyczna w funkcji (295)
  • Wywołania funkcji rekurencyjnej (297)
    • Stosowanie rekurencji (300)
  • Programowanie w C++/CLI (300)
    • Funkcje przyjmujące zmienną liczbę argumentów (301)
    • Argumenty funkcji main() (302)
  • Podsumowanie (303)
  • Ćwiczenia (304)

Rozdział 6. O strukturze programu - ciąg dalszy (305)

  • Wskaźniki do funkcji (306)
    • Deklarowanie wskaźników do funkcji (306)
    • Wskaźnik do funkcji jako argument (309)
    • Tablice wskaźników do funkcji (311)
  • Inicjalizowanie parametrów funkcji (312)
  • Wyjątki (314)
    • Wywoływanie wyjątków (316)
    • Przechwytywanie wyjątków (316)
    • Obsługa wyjątków w MFC (318)
  • Obsługa błędów przydzielania pamięci (318)
  • Przeładowywanie funkcji (320)
    • Czym jest przeładowywanie funkcji (321)
    • Kiedy stosować przeładowywanie funkcji (323)
  • Szablony funkcji (323)
    • Stosowanie szablonu funkcji (324)
  • Przykład używania funkcji (326)
    • Implementacja kalkulatora (326)
    • Usuwanie spacji z łańcucha (330)
    • Obliczanie wartości wyrażenia (330)
    • Obliczanie wartości składnika (333)
    • Analizowanie liczby (334)
    • Składanie całego programu (337)
    • Rozszerzanie programu (339)
    • Wydobywanie podłańcucha (340)
    • Uruchamianie zmodyfikowanego programu (343)
  • Programowanie w C++/CLI (343)
    • Funkcje generyczne (345)
    • Kalkulator CLR (351)
  • Podsumowanie (357)
  • Ćwiczenia (358)

Rozdział 7. Definiowanie własnych typów danych (359)

  • Struktury w języku C++ (360)
    • Czym jest struktura (360)
    • Definiowanie struktury (360)
    • Inicjalizowanie struktury (361)
    • Uzyskiwanie dostępu do pól struktury (361)
    • Pomoc mechanizmu Intellisense w pracy ze strukturami (365)
    • Struktura RECT (366)
    • Używanie wskaźników ze strukturami (367)
  • Typy danych, obiekty, klasy i egzemplarze (369)
  • Zrozumieć klasy (372)
    • Definiowanie klasy (373)
    • Deklarowanie obiektów klasy (373)
    • Uzyskiwanie dostępu do zmiennych składowych klasy (374)
    • Funkcje składowe klasy (376)
    • Umiejscowienie definicji funkcji składowej (378)
    • Funkcje inline (379)
  • Konstruktory klas (380)
    • Czym jest konstruktor (380)
    • Konstruktor domyślny (382)
    • Przypisywanie domyślnych wartości parametrom umieszczonym w klasach (385)
    • Używanie listy inicjalizacyjnej w konstruktorze (387)
  • Prywatne składowe klasy (387)
    • Uzyskiwanie dostępu do prywatnych zmiennych składowych klasy (390)
    • Przyjaciele klasy (391)
    • Domyślny konstruktor kopiujący (394)
  • Wskaźnik this (395)
  • Stałe obiekty klasy (398)
    • Stałe funkcje składowe klasy (399)
    • Definiowanie funkcji składowej poza klasą (400)
  • Tablice obiektów klasy (401)
  • Składowe statyczne klasy (402)
    • Statyczne zmienne składowe klasy (403)
    • Statyczne funkcje składowe klasy (405)
  • Wskaźniki i referencje do obiektów klasy (406)
    • Wskaźniki do obiektów (406)
    • Referencje do obiektów (409)
  • Programowanie w C++/CLI (411)
    • Definiowanie typów klas wartości (412)
    • Definiowanie typów referencyjnych (417)
    • Właściwości klasy (420)
    • Pola initonly (433)
    • Konstruktor statyczny (434)
  • Podsumowanie (435)
  • Ćwiczenia (436)

Rozdział 8. Więcej na temat klas (439)

  • Destruktory klas (439)
    • Czym jest destruktor (440)
    • Destruktor domyślny (440)
    • Destruktory i dynamiczne przydzielanie pamięci (442)
  • Implementacja konstruktora kopiującego (445)
  • Dzielenie pamięci pomiędzy zmiennymi (448)
    • Definiowanie unii (448)
    • Unie anonimowe (450)
    • Unie w klasach i strukturach (450)
  • Przeładowywanie operatorów (450)
    • Implementacja przeładowanego operatora (451)
    • Implementacja pełnej obsługi operatora (454)
    • Przeładowywanie operatora przypisania (458)
    • Przeładowywanie operatora dodawania (464)
    • Przeładowywanie operatorów inkrementacji i dekrementacji (468)
  • Szablony klas (468)
    • Definiowanie szablonu klasy (469)
    • Tworzenie obiektów klasy szablonu (472)
    • Szablony klas z wieloma parametrami (475)
  • Używanie klas (477)
    • Interfejs klasy (477)
    • Definiowanie problemu (477)
    • Implementacja klasy (478)
    • Definiowanie klasy CBox (486)
    • Zastosowanie klasy CBox (497)
  • Organizowanie kodu programu (500)
    • Nazewnictwo plików programu (500)
  • Programowanie w C++/CLI (502)
    • Przeładowywanie operatorów w klasach wartości (503)
    • Przeładowywanie operatorów inkrementacji i dekrementacji (508)
    • Przeładowywanie operatorów w klasach referencyjnych (509)
  • Podsumowanie (511)
  • Ćwiczenia (512)

Rozdział 9. Dziedziczenie i funkcje wirtualne (515)

  • Podstawy programowania zorientowanego obiektowo (OOP) (515)
  • Dziedziczenie w klasach (517)
    • Czym jest klasa bazowa (517)
    • Tworzenie klas pochodnych (518)
  • Kontrola dostępu do dziedziczonych składowych (521)
    • Działanie konstruktora w klasie pochodnej (524)
    • Deklarowanie chronionych składowych klasy (528)
    • Poziom dostępu do dziedziczonych składowych klasy (531)
  • Konstruktor kopiujący w klasie pochodnej (532)
  • Składowe klasy jako przyjaciele (537)
    • Klasy zaprzyjaźnione (538)
    • Ograniczenia klas zaprzyjaźnionych (538)
  • Funkcje wirtualne (539)
    • Czym jest funkcja wirtualna (541)
    • Używanie wskaźników do obiektów klas (544)
    • Używanie referencji z funkcjami wirtualnymi (545)
    • Funkcje czysto wirtualne (547)
    • Klasy abstrakcyjne (548)
    • Pośrednie klasy bazowe (551)
    • Wirtualne destruktory (553)
  • Rzutowanie pomiędzy typami klasowymi (559)
  • Klasy zagnieżdżone (559)
  • Programowanie w C++/CLI (563)
    • Dziedziczenie w C++/CLI (563)
    • Klasy interfejsowe (569)
    • Definiowanie klas interfejsowych (570)
    • Klasy i asemblacje (574)
    • Definiowanie nowych funkcji (579)
    • Delegaty i zdarzenia (579)
    • Finalizatory i destruktory w klasach referencyjnych (592)
    • Klasy generyczne (594)
  • Podsumowanie (605)
  • Ćwiczenia (607)

Rozdział 10. Debugowanie (611)

  • Co znaczy debugowanie (611)
    • Błędy oprogramowania (613)
    • Najczęściej spotykane błędy (614)
  • Podstawowe operacje debugowania (615)
    • Ustawianie punktów wstrzymania (617)
    • Ustawianie punktów śledzenia (619)
    • Rozpoczynanie debugowania (620)
    • Zmienianie wartości zmiennej (625)
  • Dodawanie kodu debugującego (625)
    • Asercje (626)
    • Dodawanie własnego kodu debugowania (627)
  • Debugowanie programu (633)
    • Stos wywołań (633)
    • Szukanie błędu krok po kroku (635)
  • Testowanie rozszerzonej klasy (638)
    • Odnajdywanie następnego błędu (641)
  • Debugowanie pamięci dynamicznej (641)
    • Funkcje sprawdzające obszar wolnej pamięci (642)
    • Sterowanie operacjami debugowania obszaru wolnej pamięci (643)
    • Dane wyjściowe debuggera obszaru wolnej pamięci (644)
  • Debugowanie programów w C++/CLI (650)
    • Używanie klas Debug i Trace (650)
  • Podsumowanie (659)

Rozdział 11. Założenia programowania dla systemu Windows (661)

  • Podstawy programowania dla systemu Windows (662)
    • Elementy okna (663)
    • Programy dla Windowsa i system operacyjny (664)
    • Programy sterowane zdarzeniami (665)
    • Komunikaty Windowsa (665)
    • Windows API (666)
    • Typy danych w systemie Windows (666)
    • Notacja w programach dla systemu Windows (667)
  • Struktura programu dla systemu Windows (668)
    • Funkcja WinMain() (669)
    • Funkcje przetwarzania komunikatów (681)
    • Prosty program dla systemu Windows (686)
  • Organizacja programu dla systemu Windows (686)
  • Microsoft Foundation Classes (689)
    • Notacja MFC (689)
    • Jak jest ustrukturyzowany program MFC (690)
    • Korzystanie z formularzy systemu Windows (693)
  • Podsumowanie (695)

Rozdział 12. Programowanie dla systemu Windows z wykorzystaniem Microsoft Foundation Classes (699)

  • Architektura dokument-widok w MFC (700)
    • Czym jest dokument (700)
    • Interfejsy dokumentu (700)
    • Czym jest widok (701)
    • Łączenie dokumentu i jego widoków (702)
    • Aplikacja a MFC (702)
  • Tworzenie aplikacji MFC (705)
    • Tworzenie aplikacji SDI (707)
    • Wynik działania MFC Application Wizard (710)
    • Tworzenie aplikacji MDI (721)
  • Podsumowanie (724)
    • Ćwiczenia (724)

Rozdział 13. Praca z menu i paskami narzędzi (727)

  • Komunikacja z systemem Windows (727)
    • Zrozumieć mapy komunikatów (728)
    • Kategorie komunikatów (731)
    • Obsługa komunikatów w programie (732)
  • Rozwijanie programu Sketcher (733)
  • Elementy menu (734)
    • Tworzenie i edycja zasobów menu (734)
  • Dodawanie procedur obsługi dla komunikatów menu (739)
    • Wybieranie klasy obsługującej komunikaty menu (740)
    • Tworzenie funkcji komunikatu menu (741)
    • Tworzenie kodu dla funkcji komunikatów menu (743)
    • Dodawanie procedur obsługi komunikatów uaktualniających interfejs użytkownika (747)
  • Dodawanie przycisków paska narzędzi (752)
    • Edycja właściwości przycisku paska narzędzi (753)
    • Testowanie przycisków narzędzi (754)
    • Dodawanie wskazówek (755)
  • Podsumowanie (756)
  • Ćwiczenia (757)

Rozdział 14. Rysowanie w oknie (759)

  • Podstawy rysowania w oknie (759)
    • Obszar klienta okna (760)
    • Graphical Device Interface (761)
  • Mechanizm rysowania w Visual C++ (763)
    • Klasa widoku w aplikacji (763)
    • Klasa CDC (765)
  • Rysowanie grafiki w praktyce (774)
  • Programowanie myszy (776)
    • Komunikaty z myszy (777)
    • Procedury obsługi komunikatów myszy (779)
    • Rysowanie za pomocą myszy (781)
  • Testowanie szkicownika (805)
    • Uruchamianie przykładu (806)
    • Przechwytywanie komunikatów myszy (807)
  • Podsumowanie (808)
  • Ćwiczenia (809)

Rozdział 15. Tworzenie dokumentu i poprawianie widoku (811)

  • Czym są klasy kolekcji (811)
    • Typy kolekcji (812)
    • Klasy kolekcji z kontrolą typów (813)
    • Kolekcje obiektów (813)
    • Kolekcje wskaźników z kontrolą typów (823)
  • Korzystanie z szablonu klasy CList (825)
    • Rysowanie krzywej (826)
    • Definiowanie klasy CCurve (827)
    • Implementacja klasy CCurve (829)
    • Sprawdzanie klasy CCurve (830)
  • Tworzenie dokumentu (831)
    • Używanie wzorca CTypedPtrList (831)
  • Poprawianie widoku (837)
    • Uaktualnianie wielokrotnych widoków (837)
    • Przewijanie widoków (840)
    • Korzystanie z trybu mapowania MM_LOENGLISH (844)
  • Usuwanie i przesuwanie kształtów (846)
  • Implementacja menu kontekstowego (847)
    • Łączenie menu z klasą (848)
    • Wybieranie menu kontekstowego (850)
    • Podświetlanie elementów (855)
    • Obsługa komunikatów menu (860)
  • Rozwiązywanie problemu nakładających się elementów (867)
  • Podsumowanie (869)
    • Ćwiczenia (870)

Rozdział 16. Praca z oknami dialogowymi i kontrolkami (871)

  • Poznaj okna dialogowe (871)
  • Poznaj kontrolki (872)
    • Wspólne kontrolki (874)
  • Tworzenie zasobu okna dialogowego (874)
    • Dodawanie kontrolek do okna dialogowego (875)
  • Programowanie okna dialogowego (877)
    • Dodawanie klasy dialogu (877)
    • Modalne i niemodalne okna dialogowe (878)
    • Wyświetlanie okna dialogowego (878)
  • Obsługa kontrolek okna dialogowego (882)
    • Inicjalizowanie kontrolek (882)
    • Obsługa komunikatów przycisku opcji (884)
  • Kończenie operacji okna dialogowego (885)
    • Dodawanie szerokości pióra do dokumentu (885)
    • Dodawanie szerokości pióra do elementów (886)
    • Tworzenie elementów w widoku (887)
    • Testowanie okna dialogowego (888)
  • Używanie pokrętła (889)
    • Dodawanie elementu menu Scale oraz przycisku paska narzędzi (889)
    • Tworzenie pokrętła (889)
    • Generowanie klasy okna dialogowego Scale (892)
    • Wyświetlanie pokrętła (895)
  • Korzystanie ze współczynnika skali (896)
    • Skalowalne tryby mapowania (896)
    • Ustawianie rozmiaru dokumentu (897)
    • Ustawianie trybu mapowania (898)
    • Implementowanie przewijania ze skalowaniem (900)
  • Praca z paskami stanu (902)
    • Dodawanie paska stanu do ramki (902)
  • Używanie pól list (906)
    • Usuwanie okna dialogowego Scale (907)
    • Tworzenie kontrolki pola list (907)
  • Korzystanie z kontrolki pola tekstowego (910)
    • Tworzenie zasobu pola tekstowego (911)
    • Tworzenie klasy okna dialogowego (912)
    • Dodawanie elementu menu Text (914)
    • Definiowanie elementu Text (915)
    • Implementacja klasy CText (916)
    • Tworzenie elementu Text (917)
  • Podsumowanie (919)
  • Ćwiczenia (920)

Rozdział 17. Przechowywanie i drukowanie dokumentów (921)

  • Poznaj serializację (922)
  • Serializowanie dokumentu (922)
    • Serializacja w definicji klasy dokumentu (922)
    • Serializacja w implementacji klasy dokumentu (924)
    • Zestaw funkcji klas opartych na CObject (926)
    • Jak działa serializacja (928)
    • Jak zaimplementować serializację klasy (929)
  • Stosowanie serializacji (929)
    • Rejestrowanie zmian dokumentu (929)
    • Serializowanie dokumentu (931)
    • Serializowanie klas elementów (932)
  • Testowanie serializacji (935)
  • Przenoszenie tekstu (937)
  • Drukowanie dokumentu (939)
    • Proces drukowania (939)
  • Implementacja wielostronicowych wydruków (942)
    • Uzyskiwanie całkowitego rozmiaru dokumentu (943)
    • Przechowywanie danych drukowania (944)
    • Przygotowania do wydruku (945)
    • Porządkowanie po drukowaniu (947)
    • Przygotowywanie kontekstu urządzenia (947)
    • Drukowanie dokumentu (948)
    • Drukowanie dokumentu (952)
  • Podsumowanie (953)
  • Ćwiczenia (954)

Rozdział 18. Tworzenie własnych plików DLL (955)

  • Poznaj DLL (955)
    • Jak działają DLL (957)
    • Zawartość DLL (960)
    • Odmiany DLL (961)
  • Co umieścić w DLL (962)
  • Pisanie DLL (963)
    • Pisanie i używanie rozszerzającej DLL (963)
    • Eksportowanie zmiennych i funkcji z DLL (970)
    • Importowanie symboli do programu (971)
    • Implementowanie eksportowania symboli z DLL (972)
  • Podsumowanie (974)
  • Ćwiczenia (975)

Rozdział 19. Łączenie się ze źródłami danych (977)

  • Podstawy baz danych (977)
  • Nieco o języku SQL (980)
    • Pobieranie danych z użyciem języka SQL (980)
    • Łączenie tabel w języku SQL (982)
    • Sortowanie rekordów (985)
  • Obsługa baz danych w MFC (985)
    • Klasy MFC obsługujące ODBC (986)
  • Tworzenie aplikacji bazodanowej (987)
    • Rejestrowanie bazy danych ODBC (987)
    • Generowanie programu MFC ODBC (989)
    • Poznaj strukturę programu (992)
    • Testowanie przykładu (1002)
  • Sortowanie zestawu rekordów (1004)
    • Zmienianie podpisu okna (1004)
  • Używanie drugiego obiektu zestawu rekordów (1005)
    • Dodawanie klasy zestawu rekordów (1006)
    • Dodawanie klasy widoku dla zestawu rekordów (1009)
    • Dostosowywanie zestawu rekordów (1013)
    • Dostęp do wielu widoków tablic (1016)
    • Przeglądanie zamówień na produkt (1022)
  • Przeglądanie informacji o kliencie (1022)
    • Dodawanie zestawu rekordów dla informacji o kliencie (1023)
    • Tworzenie zasobu okna dialogowego z informacjami o kliencie (1023)
    • Tworzenie klasy widoku dla informacji o kliencie (1024)
    • Dodawanie filtra (1026)
    • Implementacja parametru filtra (1028)
    • Łączenie okna dialogowego Order z oknem dialogowym Customer (1029)
    • Testowanie przeglądarki bazy danych (1031)
  • Podsumowanie (1032)
  • Ćwiczenia (1032)

Rozdział 20. Aktualizacja źródeł danych (1033)

  • Operacje aktualizacji (1033)
    • Operacje aktualizacji CRecordSet (1034)
    • Transakcje (1036)
  • Prosty przykład uaktualnienia (1038)
    • Dostosowywanie aplikacji (1040)
  • Zarządzanie procesem aktualizacji (1042)
    • Implementacja trybu uaktualniania (1044)
  • Dodawanie wierszy do tabeli (1052)
    • Proces wpisywania zamówienia (1053)
    • Tworzenie zasobów (1054)
    • Tworzenie zestawów rekordów (1055)
    • Tworzenie widoków zestawu rekordów (1055)
    • Dodawanie kontrolek do zasobów dialogu (1060)
    • Implementacja przełączania okien dialogowych (1064)
    • Tworzenie identyfikatora zamówienia (1068)
    • Przechowywanie danych zamówienia (1073)
    • Wybieranie produktów dla zamówienia (1075)
    • Dodawanie nowego zamówienia (1077)
  • Podsumowanie (1082)
  • Ćwiczenia (1082)

Rozdział 21. Aplikacje wykorzystujące Windows Forms (1083)

  • Poznaj formularze systemu Windows (1083)
  • Poznaj aplikacje Windows Forms (1084)
    • Zmienianie właściwości formularza (1086)
    • Jak startuje aplikacja (1087)
  • Dostosowywanie GUI aplikacji (1088)
    • Dodawanie kontrolek do formularza (1089)
    • Dodawanie zakładek (1092)
    • Korzystanie z kontrolki GroupBox (1094)
    • Używanie kontrolek Button (1097)
    • Korzystanie z kontrolki WebBrowser (1099)
    • Sposób działania aplikacji Winning Application (1100)
    • Dodawanie menu kontekstowego (1102)
    • Tworzenie procedur obsługi zdarzeń (1102)
    • Obsługa zdarzeń dla menu Limits (1108)
    • Tworzenie okna dialogowego (1109)
    • Używanie okna dialogowego (1115)
    • Dodawanie drugiego okna dialogowego (1120)
    • Implementacja elementu menu Help/About (1128)
    • Obsługa kliknięcia przycisku (1128)
    • Reagowanie na menu kontekstowe (1131)
  • Podsumowanie (1138)
  • Ćwiczenia (1139)

Rozdział 22. Dostęp do źródeł danych w aplikacjach Windows Forms (1141)

  • Praca ze źródłami danych (1142)
  • Dostęp do danych i ich wyświetlanie (1143)
  • Używanie kontrolki DataGridView (1143)
  • Używanie kontrolki DataGridView w trybie niezwiązanym (1145)
  • Dostosowywanie kontrolki DataGridView (1151)
    • Dostosowywanie komórek nagłówkowych (1152)
    • Dostosowywanie pozostałych komórek (1153)
    • Dynamiczne ustawianie stylów komórki (1160)
  • Używanie trybu związanego (1165)
  • Komponent BindingSource (1166)
  • Korzystanie z kontrolki BindingNavigator (1171)
  • Wiązanie z pojedynczymi kontrolkami (1174)
  • Praca z wieloma tabelami (1178)
  • Podsumowanie (1179)
  • Ćwiczenia (1180)

Dodatek A Słowa kluczowe w języku C++ (1181)

Dodatek B Kody ASCII (1183)

Skorowidz (1189)

©2007 Włodzimierz Gajda | prace magisterskie | Dubai | Korekta prac magisterskich , Ebooki programowanie androida, Pozycjonowanie stron Poznań