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