Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00120 002083 22765535 na godz. na dobę w sumie
wyszukaj dokładnie | pobierz wtyczkę
Visual C++ 2005. Od podstaw - książka
Visual C++ 2005. Od podstaw - książka
Autor: Liczba stron: 1224
Wydawca: Helion Język publikacji: polski
ISBN: 83-246-0652-1 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> .net - programowanie
Porównaj ceny (książka, ebook, audiobook).
Czytaj online.
Komentuj

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

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.

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

Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

Visual C++ 2005. Od podstaw Autor: Ivor Horton T³umaczenie: £ukasz Piwko (wstêp, rozdz. 1-10), Marcin Rogó¿ (rozdz. 11-22, dod. A, B) ISBN: 978-83-246-0652-8 Tytu³ orygina³u: Beginning Visual C++ 2005 Format: B5, stron: 1224 oprawa twarda 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 Wydawnictwo Helion ul. Koœciuszki 1c 44-100 Gliwice tel. 032 230 98 63 e-mail: helion@helion.pl 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 6 Visual C++ 2005. Od podstaw 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 Spis treści 7 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 8 Visual C++ 2005. Od podstaw 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 Spis treści 9 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 10 Visual C++ 2005. Od podstaw 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 Spis treści 11 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 12 Visual C++ 2005. Od podstaw 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 Spis treści 13 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 14 Visual C++ 2005. Od podstaw 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 Spis treści 15 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 16 Visual C++ 2005. Od podstaw Rozdział 20. Aktualizacja źródeł danych .............................................................................................1033 Operacje aktualizacji ................................................................................................. 1033 Operacje aktualizacji CRecordSet ......................................................................... 1034 Transakcje ......................................................................................................... 1036 Prosty przykład uaktualnienia .................................................................................... 1038 Dostosowywanie aplikacji ................
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Visual C++ 2005. Od podstaw
Autor:
Sklep
Format
Cena
Helion.pl Helion.pl
książka
127,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ą: