Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00532 010062 11029917 na godz. na dobę w sumie
ABC programowania w C++ - książka
ABC programowania w C++ - książka
Autor: Liczba stron: 272
Wydawca: Helion Język publikacji: polski
ISBN: 83-7197-558-9 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> c++ - programowanie
Porównaj ceny (książka, ebook, audiobook).
Część pierwsza książki jest rodzajem samouczka programowania. Prezentuje elementy języka C oraz oparte na klasach, dziedziczeniu i polimorfizmie rozszerzenia obiektowe właściwe dla C++. Takie konstrukcje języka jak pętle, łańcuchy znakowe, tablice, funkcje czy konstruktory klas przedstawiono na możliwie krótkich przykładach. Dla każdego z nich podano kod źródłowy, opis działania, wydruk i zrzut ekranu z wynikami. Szczególną uwagę zwrócono na wyrobienie u Czytelnika sprawności w posługiwaniu się wskaźnikami do łańcuchów, tablic i funkcji. Omówiono przydzielanie i zwalnianie pamięci na stercie przy użyciu operatorów new i delete. Uwzględniono tworzenie przemieszczalnych okienek w trybie tekstowym oraz grafiki punktowej przy wykorzystaniu funkcji oferowanych przez interfejs BGI.

W części drugiej podano kody źródłowe i opisy bardziej zaawansowanych programów. Sześć z nich pracuje w trybie tekstowym a cztery w trybie graficznym. Przykładowo, program Piano symuluje organy a program Mousebox wyświetla sterowane myszą przemieszczalne listy wyboru. W programie City na uwagę zasługuje funkcja takeStr umożliwiająca wpis, przewijanie i modyfikacje łańcucha znakowego dłuższego niż widoczne na ekranie okienko wpisowe. Program Zegar prezentuje dwa przesuwalne strzałkami zegary, z możliwością włączania i wyłączania melodii. Program Drawthru pokazuje użycie myszy do narysowania kilku krzywych wykresu, a następnie do wskazania myszą jednej z nich. W sumie, lektura obydwu części książki winna przybliżyć Czytelnikowi zasady tworzenia programów tak tekstowych jak i graficznych.

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

Darmowy fragment publikacji:

ABC programowania w C++ Autor: Jan Rusek ISBN: 83-7197-558-9 Format: B5, stron: oko‡o 200 CzŒ(cid:156)(cid:230) pierwsza ksi„¿ki jest rodzajem samouczka programowania. Prezentuje elementy jŒzyka C oraz oparte na klasach, dziedziczeniu i polimorfizmie rozszerzenia obiektowe w‡a(cid:156)ciwe dla C++. Takie konstrukcje jŒzyka jak pŒtle, ‡aæcuchy znakowe, tablice, funkcje czy konstruktory klas przedstawiono na mo¿liwie kr(cid:243)tkich przyk‡adach. Dla(cid:160) ka¿dego z nich podano kod (cid:159)r(cid:243)d‡owy, opis dzia‡ania, wydruk i zrzut ekranu z(cid:160) wynikami. Szczeg(cid:243)ln„ uwagŒ zwr(cid:243)cono na wyrobienie u Czytelnika sprawno(cid:156)ci w(cid:160) pos‡ugiwaniu siŒ wska(cid:159)nikami do ‡aæcuch(cid:243)w, tablic i funkcji. Om(cid:243)wiono przydzielanie i zwalnianie pamiŒci na stercie przy u¿yciu operator(cid:243)w new i delete. UwzglŒdniono tworzenie przemieszczalnych okienek w trybie tekstowym oraz grafiki punktowej przy wykorzystaniu funkcji oferowanych przez interfejs BGI. W czŒ(cid:156)ci drugiej podano kody (cid:159)r(cid:243)d‡owe i opisy bardziej zaawansowanych program(cid:243)w. Sze(cid:156)(cid:230) z nich pracuje w trybie tekstowym a cztery w trybie graficznym. Przyk‡adowo, program Piano symuluje organy a program Mousebox wy(cid:156)wietla sterowane mysz„ przemieszczalne listy wyboru. W programie City na uwagŒ zas‡uguje funkcja takeStr umo¿liwiaj„ca wpis, przewijanie i modyfikacje ‡aæcucha znakowego d‡u¿szego ni¿ widoczne na ekranie okienko wpisowe. Program Zegar prezentuje dwa przesuwalne strza‡kami zegary, z mo¿liwo(cid:156)ci„ w‡„czania i wy‡„czania melodii. Program Drawthru pokazuje u¿ycie myszy do narysowania kilku krzywych wykresu, a nastŒpnie do wskazania mysz„ jednej z nich. W sumie, lektura obydwu czŒ(cid:156)ci ksi„¿ki winna przybli¿y(cid:230) Czytelnikowi zasady tworzenia program(cid:243)w tak tekstowych jak i graficznych. IDZ DO IDZ DO PRZYK£ADOWY ROZDZIA£ PRZYK£ADOWY ROZDZIA£ SPIS TRE(cid:140)CI SPIS TRE(cid:140)CI KATALOG KSI¥flEK KATALOG KSI¥flEK KATALOG ONLINE KATALOG ONLINE ZAM(cid:211)W DRUKOWANY KATALOG ZAM(cid:211)W DRUKOWANY KATALOG TW(cid:211)J KOSZYK TW(cid:211)J KOSZYK DODAJ DO KOSZYKA DODAJ DO KOSZYKA CENNIK I INFORMACJE CENNIK I INFORMACJE ZAM(cid:211)W INFORMACJE ZAM(cid:211)W INFORMACJE O NOWO(cid:140)CIACH O NOWO(cid:140)CIACH ZAM(cid:211)W CENNIK ZAM(cid:211)W CENNIK CZYTELNIA CZYTELNIA FRAGMENTY KSI¥flEK ONLINE FRAGMENTY KSI¥flEK ONLINE Wydawnictwo Helion ul. Chopina 6 44-100 Gliwice tel. (32)230-98-63 e-mail: helion@helion.pl Część I Wprowadzenie do języka C++..........................................7 Rozdział 1. Wprowadzenie..................................................................................9 Rozdział 2. Kompilator Borland C++ .................................................................11 Rozdział 3. Kompilator Microsoft Visual C++ ....................................................15 Rozdział 4. Podstawowe elementy programu ....................................................19 Funkcja główna main........................................................................................ 19 Funkcje i zbiory nagłówkowe........................................................................... 23 Wskaźnik do łańcucha znaków......................................................................... 25 Strumień wyjścia cout....................................................................................... 28 Rozdział 5. Wydruk na ekran ............................................................................31 Funkcja clrscr w środowisku Borland C++ ...................................................... 31 Zmienne predefiniowane .................................................................................. 33 Kolor wydruku .................................................................................................. 36 Formatowanie wydruku .................................................................................... 39 Formatowany wpis do łańcucha ....................................................................... 42 Odczyt z pliku ................................................................................................... 45 Rozdział 6. Funkcje .........................................................................................49 Przekaz parametrów przez referencję ............................................................... 49 Odczyt z klawiatury .......................................................................................... 51 Zwrot wskaźnika przez funkcję ........................................................................ 55 Wskaźnik do funkcji ......................................................................................... 57 Tablica wskaźników do funkcji ........................................................................ 59 Tablice wielowymiarowe typów int ................................................................. 61 Tablice wielowymiarowe typów char............................................................... 63 Wskaźnik do wskaźnika.................................................................................... 65 Wskaźnik do funkcji na liście argumentów...................................................... 68 Argument domniemany .................................................................................... 70 Instrukcja continue............................................................................................ 72 Przeładowanie funkcji....................................................................................... 73 C:AndrzejPDFABC programowania w C++!spis tresci.doc 3 4 ABC programowania w C++ Rozdział 7. Klasy i struktury.............................................................................77 Konstruktor ....................................................................................................... 77 Konstruktor domniemany ................................................................................. 80 Operatory new i delete ...................................................................................... 83 Konstruktor w roli konwertera.......................................................................... 85 Kopiowanie głębokie ........................................................................................ 89 Przeładowanie operatorów................................................................................ 92 Lista inicjalizatorów ......................................................................................... 96 Tablice obiektów definiowanych...................................................................... 98 Dziedziczenie.................................................................................................. 100 Dziedziczenie dwóch klas............................................................................... 102 Funkcja wirtualna ........................................................................................... 103 Typ enum i instrukcja typedef ........................................................................ 106 Wskaźnik this.................................................................................................. 109 Rozdział 8. Grafika tekstowa .........................................................................113 Wskazanie pola wyboru kursorem.................................................................. 113 Wskazanie pola wyboru tabulatorem.............................................................. 116 Wskazanie pola wyboru myszą....................................................................... 121 Pozycjonowanie pola prostokątnego za pomocą myszy................................. 125 Rozdział 9. Grafika punktowa .........................................................................131 Okno lokalne................................................................................................... 131 Pozycjonowanie obiektu za pomocą myszy ................................................... 137 Kopiowanie wycinków obrazu do pamięci..................................................... 143 Rozdział 10. Argumenty wywołania programu i zmienne środowiskowe ..............151 Rozdział 11. Kompilacja programu złożonego z kilku plików ..............................155 Część II Przykłady ...................................................................159 Rozdział 12. Program FACT.cpp obliczający silnię N = n!...................................161 Rozdział 13. Program COSI.cpp obliczający wartość cos(x)...............................165 Rozdział 14. Program CITY.cpp do wpisu par miast i ich odległości ...................173 Rozdział 15. Program PIANO.cpp do symulacji organów ....................................187 Rozdział 16. Program ZEGAR.cpp do symulacji 2 zegarów ................................195 Rozdział 17. Program DYNATREE.cpp do tworzenia binarnego drzewa dynamicznego ...................................................209 Rozdział 18. Program REGRE.cpp kreślący prostą regresji dla punktów odczytanych z pliku zewnętrznego .............................217 Rozdział 19. Program MOUSEBOX.cpp do przesuwania myszą okien wyboru ......229 Rozdział 20. Program DRAWTHRU.cpp do rysowania myszą kilku linii oraz do wybrania i podświetlenia jednej z nich...............................243 4 C:AndrzejPDFABC programowania w C++!spis tresci.doc Spis treści 5 Dodatki .......................................................................................257 Dodatek A Kody ASCII ..................................................................................259 Dodatek B Kody klawiatury rozszerzonej ........................................................263 C:AndrzejPDFABC programowania w C++!spis tresci.doc 5 Rozdział 9. Okno lokalne Współrzędne punktu na ekranie można opisywać w układzie bezwzględnym dotyczącym całego ekranu lub w podoknie (viewport) posiadającym lokalny układ współrzędnych, tak jak ma to miejsce w programie p9_1.cpp. W programie tym na początku funkcji +2 uruchamiamy tryb graficzny pracy monitora. Można to uczynić na dwa sposoby: przez dołączenie (wlinkowanie) sterowników grafiki, tak aby sterowniki te stanowiły integralną część naszego programu, lub przez pozostawienie tych sterowników poza naszym programem i korzystanie z nich, w sposób automatyczny, w czasie wykonywa- nia programu. W tym drugim przypadku, używane w programie sterowniki grafiki muszą być obecne na platformie, na której wykonujemy nasz program. Sterowników tych do- starcza środowisko Borland w pliku Bgi. Uruchomienie trybu graficznego dla tego przypadku realizuje (w naszym programie) funkcja 78+68. Druga możliwość (z „wlin- kowaniem”, czyli trwałym dołączeniem sterowników grafiki) realizowana jest (w na- szym programie) przez funkcję  23;+2+, którą obecnie unieruchamiamy poprzez objęcie jej symbolami (cid:15) (cid:15) . Ten sposób odwoływania się do sterowników grafiki pokazany zostanie w drugiej części tego podrozdziału. W funkcji +2 utworzymy dwa prostokątne podokna poprzez dwukrotne wywołanie konstruktora klasy 23. Na liście argumentów tego konstruktora przekazujemy mu parametry , 8, 6, ,, czyli współrzędne wierzchołków: lewego górnego i prawego dolne- go kreowanego okna. W obu wywołaniach współrzędne te są różne, tak aby uzyskać wzajemne przesunięcie podokien, jak jest to pokazane na rysunku 9.1. Współrzędne wierzchołków podajemy jako liczby względne odniesione do maksymalnych wymia- rów, odpowiednio — w kierunku poziomym i pionowym. Te maksymalne wymiary uzyskujemy z funkcji 1/8+ oraz 1/8+. Klasa 23 posiada funkcję własną 368, w której za pomocą funkcji bibliotecznej 7/8:/;4368, ustalamy lokalne układy odnie- sienia dla obiektów klasy 23: pierwszego, noszącego nazwę  i drugiego, wskazy- wanego przez wskaźnik 4. Klasa 23 posiada dwie dalsze funkcje własne: 47 (do kreślenia elipsy) oraz 2+ (do wykreślenia prostej). Na rzecz obiektu  wywołamy funkcję 47, co spowoduje wykreślenie w pierwszym podoknie (viewport) elipsy C:AndrzejPDFABC programowania w C++ 09.doc 131 132 Czlć I  Wprowadzenie do jzyka C++ usytuowanej centralnie względem tego podokna. Ponieważ jednak przy kreacji tego podokna ostatnim parametrem przekazanym do funkcji 7/8:/;4368 była jedynka (z wier- sza 36.), to części figur geometrycznych (w tym przypadku elipsy) wychodzące poza obszar podokna zostaną obcięte. Stąd przycięcie elipsy widoczne na rysunku 9.1. Natomiast na rzecz drugiego okna, wskazywanego przez wskaźnik 4, zastosujemy funkcję 2+. Ponieważ przy kreacji okna wskazywanego przez wskaźnik 4 ostatnim parametrem przekazanym funkcji 7/8:/;4368 było zero (z wiersza 37.), więc linia pro- sta zostanie narysowana w całości (bez ograniczenia jej tylko do obszaru podokna). Oto program p9_1.cpp: 2-9./78.,   2-9./-323   2-9./16+4-7   2-9./78.3    :3.78+68(cid:30)(cid:31)  2878/6$$’86,  2816+4(cid:30)78/6’86,’ (cid:31)  2816+4(cid:30)78/6’86,’-1(cid:31) 0(cid:30)16+46/798(cid:30)(cid:31)16(cid:31) -46280(cid:30)6+0+(cid:31)1/8-(cid:30)(cid:31)/8(cid:30) (cid:31)   )))   @  :3. 23;+2+(cid:30)(cid:31)  0(cid:30)6/178/6,1.6:/6(cid:30) ).6:/6(cid:31) (cid:31)  -46280(cid:30)6+0+ 63/-8(cid:31)1/8-(cid:30)(cid:31)/8(cid:30) (cid:31)  2878/6$$’86,  2816+4(cid:30)78/6’86,’(cid:31)  0(cid:30)16+46/798(cid:30)(cid:31)16(cid:31)  -46280(cid:30)6+0+;23;+2+(cid:31)1/8-(cid:30)(cid:31)/8(cid:30) (cid:31)   )))  @  -+7723  49,-28’$’ ’’ ’ 4’$’$4’-3’-3’:   -+6@’7   :3. 368(cid:30)(cid:31)  :3.47(cid:30)03+86’03+86(cid:31)  :3.2+(cid:30)03+8 ’03+8 ’03+8’03+8(cid:31)  23(cid:30)03+8’03+88’03+86’03+8,’-+6@’  28-3’28-3’28: (cid:31)   ))))))))))  :3.+2(cid:30)(cid:31)  78+68(cid:30)(cid:31)    23;+2+(cid:30)(cid:31)  23(cid:30) ’ ’ ’ ’’$ ’ $’ (cid:31)  23@423(cid:30) ’ ’ ’ ’’ ’$ ’ (cid:31)   368(cid:30)(cid:31)   47(cid:30) ’ (cid:31)  4K 368(cid:30)(cid:31)  4K2+(cid:30) ’ ’ ’K (cid:31)  1/8-(cid:30)(cid:31)-37/16+4(cid:30)(cid:31)   )))))))))))))))))))))))))))))))))))))))))))))))))  2323(cid:30)03+8’03+88’03+86’03+8,’-+6@’  28-3’28-3’28: (cid:31) 132 C:AndrzejPDFABC programowania w C++ 09.doc Rozdział 9.  Grafika punktowa 133  -3(cid:30)-3(cid:31)’-3(cid:30)-3(cid:31)’: (cid:30): (cid:31)’(cid:30)(cid:31)  281/8+(cid:30)(cid:31)  281/8+(cid:30)(cid:31)  @$8@   6@,@    K$K$   4  $4$    )))  :3.23 368(cid:30)(cid:31)  7/8:/;4368(cid:30)’$’ ’’: (cid:31)  7/8078/(cid:30)#)’-3(cid:31)  ,+6(cid:30) ’ ’ ’$(cid:31)  746280(cid:30)7’7.’.’’’$(cid:31)  7/88/89780(cid:30)$)$$’$ )$$(cid:31)  7/8-336(cid:30)(cid:31)  3988/8(cid:30)’’7(cid:31)   )))  :3.2347(cid:30)03+86’03+86(cid:31)  7/8078/(cid:30)#)’-3(cid:31)  0/47/(cid:30) 4’$4’6@ 4’6@$4(cid:31)   )))  :3.232+(cid:30)03+8 ’03+8 ’03+8’03+8(cid:31)  7/82/78/(cid:30)#)’ ’(cid:31)  7/8-336(cid:30)-3(cid:31)  2/(cid:30) @ ’ @$’@ ’@$(cid:31)   Funkcjonowanie programu obsługującego grafikę punktową wymaga uruchomienia sterownika (driver) grafiki, udostępniającego implementacje funkcji pośredniczących pomiędzy programem a konkretnym typem karty graficznej. W tym wypadku chodzi o funkcje dostarczane przez BGI (Borland Graphics Interface). Funkcje te, na etapie konsolidacji programu, można dołączyć tak, że będą one wraz z programem właści- wym stanowić jednolitą całość. Inną możliwość stwarza mechanizm zwany DLL (Dy- namic Link Library) polegający na tym, że program wynikowy nie zawiera modułu z funkcjami z BGI. Jednakże moduł ten jest ładowany do pamięci w czasie wykony- wania programu, a jego funkcje są udostępniane programowi (a także innym programom ewentualnie wykonywanym równocześnie); stąd oszczędność pamięci i mniejszy rozmiar kodu wynikowego. Inicjalizację grafiki za pomocą drugiego sposobu (DLL) realizuje funkcja 78+68 w wierszu 6., a za pomocą sposobu pierwszego — funkcja  23;+2+ w wierszu 15. Sposób pierwszy jest tu nieaktywny, gdyż funkcja  2(cid:31) 3;+2+ objęta jest znakami (cid:15) (cid:15) , a jej wywołanie w funkcji +2 jest poprzedzone dwoma ukośnikami (znakami slasz). Uaktywnienia tej funkcji dokonamy w dalszej części rozdziału. Obecnie program graficzny uruchomimy za pomocą 78+68 w wierszu 34. Inicjalizacji albo otwarcia trybu graficznego dokonuje się poprzez wywołanie funkcji bibliotecznej 2816+4 (wiersz 9.), przy czym wcześniej należy nadać wartość zmiennej 78/6, tu równą stałej predefiniowanej $$. Spowoduje to, że funkcja 2816+4 sama rozpozna typ karty graficznej i dobierze dla niej najodpowiedniejszy tryb pracy. Stąd zbędność przypisywania wartości zmiennej 86, w wierszu 9. Jed- nak, jeśli chcieć uzyskać tzw. stronicowanie ekranu, to zmiennej 78/6 należy nadać wartość , a zmiennej 86, wartość , jak w programie ZEGAR.cpp, w części drugiej. Trzecim argumentem funkcji 2816+4 jest ścieżka dostępu do biblioteki BGI. C:AndrzejPDFABC programowania w C++ 09.doc 133 134 Czlć I  Wprowadzenie do jzyka C++ Może to być np.   lub, jak tu, -1. Konieczność używania w programie dwóch wstecznych ukośników  (dwóch znaków backslash) wynika stąd, że pierwszy z nich ma (w C++) znaczenie specjalne: „potraktuj następny znak dosłownie”. Efektywny jest więc dopiero drugi ukośnik wsteczny  (backslash). Zawsze należy sprawdzić powodzenie operacji uruchomienia programu graficznego. W tym celu wywo- łuje się funkcję 16+46/798 i sprawdza, czy zwróciła ona wartość predefiniowaną 16. W wierszu 24. definiowana jest klasa 23 do obsługi jednego wycinka ekranu (pod- okna lokalnego — viewport), z lokalnym układem współrzędnych. Składniki własne , $, ,  oznaczają współrzędne wierzchołków lewego górnego (Left, Top) i prawego dolnego (Right, Bottom) podokna lokalnego. Składnik  oznacza wymiar poziomy, a $ pionowy okna lokalnego. Składniki własne 4 i $4 są współrzędnymi środka podokna lokalnego (w układzie lokalnym). Składniki -3 i -3 zawierać będą infor- mację o kolorze rysunku i tła. Składnik : przyjmować będzie wartość 0 lub 1. W tym ostatnim przypadku części rysunku wystające poza zakres okna lokalnego będą niewi- doczne, czyli realizowane będzie obcinanie (clipping). W wierszu 26. widzimy wskaźnik -+6 (cid:15) łańcucha z częścią tytułu okna. Tablica pomocnicza 7 zawierać będzie cały opis okna (tytuł + współrzędne wierzchołka lewego górnego okna lokalnego). W wierszu 27. widzimy funkcję własną 368, zdefiniowaną w wierszu 54. Funkcja ta, w wierszu 55, wywołuje funkcję biblioteczną 7/8:/;4368 definiującą podokno lokalne. Na liście argumentów aktualnych tej funkcji podajemy współrzędne globalne (dla całego ekranu, z początkiem w lewym górnym rogu ekranu). Po ustaleniu podokna lokalnego, w wierszu 57. wywołujemy funkcję ,+6 (czyli słupek, lub wypełniony pro- stokąt) podając na liście argumentów współrzędne jego wierzchołków: lewego górnego i prawego dolnego. Współrzędne 0 oznaczają ustawienie wierzchołka lewego górnego na początku podokna lokalnego. Współrzędne  i $ ustawią prawy dolny wierzchołek słupka (,+6) w prawym dolnym rogu podokna lokalnego. Słupek (,+6) wypełniany jest kolorem określanym przez funkcję 7/8078/ w wierszu 56. W wierszu 58. funkcja 746280 dokonuje sformatowanego wpisu do tablicy pomocni- czej 7. Zauważmy, że wpisany do tej tablicy łańcuch będzie zawierał tytuł obiektu wskazany łańcuchem  oraz współrzędne , $ okna lokalnego (względem całego ekranu). Wyprowadzenie tekstu (łańcucha) na ekran, pozostający w trybie graficznym, zapewnia w wierszu 61. funkcja 3988/8. Kolor tego napisu określa funkcja 7/8-336 w wierszu 60. Lokalizację tekstu na ekranie wskazują dwa pierwsze argumenty funkcji 3988/8. Centrowanie tekstu wokół tej lokalizacji zapewnia funkcja 7/88/89780 w wierszu 59. W wierszu 28. widzimy funkcję własną 47 zdefiniowaną w wierszu 63. Funkcja ta, w wierszu 65, wywołuje funkcję biblioteczną 0/47/ dla argumentów będących składnikami własnymi klasy, z których 4 oznacza połowę szerokości, a $4 połowę wysokości okna lokalnego. Pozostałe dwa argumenty są długościami półosi elipsy (przeliczanymi z jednostek względnych 6 i 6 na bezwzględne, w pikselach). 134 C:AndrzejPDFABC programowania w C++ 09.doc Rozdział 9.  Grafika punktowa 135 W wierszu 29. widzimy następną funkcję własną o nazwie 2+, zdefiniowaną w wier- szu 67. Funkcja ta wywołuje funkcję biblioteczną 2/ z lokalnymi współrzędnymi początku i końca linii prostej. Instrukcje przeliczające jednostki względne  , ,  ,  na lokalne bezwzględne (w pikselach) występują na liście argumentów aktualnych funkcji 2/ w wierszu 70. Funkcja 7/82/78/ w wierszu 68. określa rodzaj linii (ciągła, przerywana, itp.) oraz jej grubość. Wartość 3 ostatniego argumentu oznacza żądanie kreślenia linii pogrubionej. W wierszu 30. widzimy konstruktor klasy 23, zdefiniowany w wierszu 44. Na liście parametrów formalnych otrzymuje on informację , 8, 6, , o położeniu wierzchołków (lewego górnego i prawego dolnego) w jednostkach względnych globalnych, takich że zero odpowiada lewemu górnemu, a jeden — prawemu dolnemu rogowi ekranu. W ciele konstruktora współrzędne te są przeliczane na współrzędne bezwzględne globalne , $, , . W tym celu w wierszu 47. (i następnym) wywołujemy funkcje 1/8+ i 1/8+ zwracające wartości maksymalne (liczone w pikselach) współrzędnych ekranu w pozio- mie i w pionie. Kolory, : (clipping) oraz łańcuch  tytułu obiektu przekazywane są do klasy za pośrednictwem listy inicjalizacyjnej (przed wierszem 47.). W programie +2 wywołujemy funkcję inicjalizującą grafikę albo z wiersza 34. (obec- nie), albo z wiersza 35. (w drugiej części niniejszego podrozdziału). W wierszu 36. kreowany jest obiekt o nazwie  poprzez wywołanie na jego rzecz konstruktora klasy 23. W wierszu 37. powtarzamy czynności z wiersza 36., ale dla obiektu  klasy 23, z tym jednak że tu (dla odmiany) wykreowany obiekt wskazy- wany jest nie nazwą, ale wskaźnikiem 4. Zauważmy, że ostatni argument w wywołaniu konstruktora wynosi: 1 w wierszu 36. i 0 w wierszu 37. Zatem, w przypadku obiektu  będzie działać mechanizm, który spowoduje obcinanie (clipping) wychodzących poza podokno lokalnych części rysowanych figur geometrycznych lub napisów. W przypadku okna  tak nie będzie. W wierszu 38. wywołujemy funkcję 4368, a w wierszu 39. funkcję 47 na rzecz obiektu . Ponieważ  jest nazwą obiektu, więc w wierszach 38. i 39. używamy ope- ratora kropki. W wierszach 40. i 41. wywołujemy funkcje 368 oraz 2+ na rzecz obiektu  wskazywanego wskaźnikiem 4. Stąd konieczność użycia operatora strzałki w tych wywołaniach funkcji. Przed zakończeniem programu należy zamknąć tryb graficzny poprzez wywołanie funkcji -37/16+4 w wierszu 42. Po skompilowaniu, konsolidacji i wykonaniu programu w trybie Windows lub MS- DOS otrzymujemy ekran, jaki przedstawiony został na rysunku 9.1. Rysunek 9.1. Ekran otrzymany w wyniku wykonania programu p9_1.exe C:AndrzejPDFABC programowania w C++ 09.doc 135 136 Czlć I  Wprowadzenie do jzyka C++ Podokno pierwsze pracuje w trybie obcinania figur wystających poza obszar podokna lokalnego, a okno drugie w trybie bez obcinania. Zauważmy, że elipsa obiektu  została obcięta na granicy podokna lokalnego ustala- nego funkcją biblioteczną 7/8:/;4368 w wierszu 55. programu. Ponieważ mechanizmu tego nie wywołano przy kreacji obiektu  (w wierszu 37.), więc linia narysowana na rzecz tego obiektu wychodzi poza granice okna lokalnego (viewport). Wykonanie powyższego programu na innym komputerze jest możliwe tylko wtedy, gdy sterowniki grafiki EGAVGA znajdują się również w katalogu C:Bc5Bgi, tzn. takim jak w wierszu 9. programu. W przeciwnym razie należy ponownie skompilować program, uaktualniając ścieżkę dostępu w wierszu 9. programu. Innym rozwiązaniem, nie wy- magającym rekompilacji, byłoby podanie w wierszu 9. programu pustej ścieżki do- stępu do sterowników grafiki (czyli ). Wtedy program (w czasie wykonania) poszu- kuje sterowników w katalogu bieżącym. Mając tak skompilowany program, przed jego wykonaniem należałoby skopiować plik Egavga (z zasobów Borland) do bieżą- cego katalogu (w którym znajduje się p9_1.exe) i wtedy dopiero go wykonać. Drugi sposób udostępniania programowi sterowników grafiki (tzn. sposób z tzw. wlinkowaniem czyli trwałym dołączeniem sterowników EGAVGA) pokażemy w pro- gramie p9_1wg.cpp (odmiana programu p9_1.cpp) zlokalizowanym w katalogu p9_1wg (o takiej samej nazwie jak program). Najpierw należy uzyskać plik Egavga.obj. W tym celu do bieżącego katalogu, np. C: Bcpp5p9_1wg, należy skopiować program Bgiobj.exe (z zasobów Borland), np. z ka- talogu C:Bc5Bgi. Kopiowanie to przeprowadzamy poza środowiskiem programowania Borland, np. wykorzystując program Eksplorator Windows. Następnie (nadal korzystając z programu Eksplorator Windows) otwieramy bieżący katalog, po czym wskazujemy myszą podane dalej pola i wpisujemy: Start|Uruchom| Bgiobj C:Bg5BgiEgavga. Po wykonaniu i zamknięciu programu Bgiobj.exe, w kata- logu C:Bcpp5p9_1wg powinien się pojawić plik Egavga.obj. Zamykamy program Eksplorator Windows. Uruchamiamy środowisko programowania Borland C++ i tworzymy nowy projekt o nazwie p9_1wg, dla platformy DOS w katalogu p9_1wg, z tym jednak że w oknie New Target zaznaczamy kwadratowe pole BGI (rysunek 2.2). Wskazując myszą na ikony File|Open odszukujemy program p9_1.cpp (w katalogu p9_1) i zapisujemy go w katalogu p9_1wg pod nazwą p9_1wg.cpp. W oknie Project naprowadzamy kursor na kwadrat z minusem tuż przed nazwą p9_1wg.exe i naciskamy prawy przycisk myszy. Pojawia się lista wyboru, na której lewym przyciskiem myszy wskazujemy polecenie Add node. Pojawi się okno Add to Project List. W polu Pliki typu rozwijamy listę i wybieramy opcję All files (*.*). Myszą wskazujemy na Egavga.obj, jak pokazano na rysunku 9.1a. 136 C:AndrzejPDFABC programowania w C++ 09.doc Rozdział 9.  Grafika punktowa 137 Rysunek 9.1a. Okno środowiska programowania Borland w czasie dodawania do już utworzonego projektu (w bieżącym katalogu) pliku Egavga.obj w celu trwałego dołączenia sterowników grafiki Po wskazaniu myszą przycisku Otwórz, okno Add to Project List znika, a w oknie Project pojawia się nowy węzeł (node) egavga.obj, jak pokazano na rysunku 9.1b. Rysunek 9.1b. Fragment okna środowiska programowania Borland po dodaniu do projektu pliku Egavga.obj Uaktywniamy (poprzez kliknięcie) okno z plikiem programu p9_1wg.cpp i dokonu- jemy w nim modyfikacji polegającej na uruchomieniu funkcji  23;+2+ zamiast 78+68. Po skompilowaniu i konsolidacji otrzymujemy program, którego integralną częścią są sterowniki grafiki EGAVGA. Wykonanie tego programu prowadzi do ta- kiego samego wydruku, jak wydruk przedstawiony na rysunku 9.1. Pozycjonowanie obiektu za pomocą myszy Do przesuwania obiektów takich jak figury geometryczne można użyć myszy, podobnie jak zostanie to zrobione w programie p9_2.cpp. W programie tym dostęp do sterow- ników grafiki realizujemy sposobem przedstawionym w drugiej części poprzedniego podrozdziału, tzn. poprzez wywołanie funkcji  23;+2+. (Funkcja 78+68 jest tu nieczynna). W tym celu uruchamiamy projekt w katalogu p9_2 z zaznaczeniem pola BGI (widocznego na rysunku 2.2) i z dodaniem węzła (node) w postaci pliku egavga. obj (jak na rysunku 9.1b). Plik ten można np. przegrać z katalogu p9_1wg lub wskazać go w tym katalogu w czasie dołączania nowego węzła. Oczywiście można go też wykreować od nowa za pomocą programu Bgiobj.exe, tak jak zrobiono to w drugiej części poprzedniego podrozdziału. C:AndrzejPDFABC programowania w C++ 09.doc 137 138 Czlć I  Wprowadzenie do jzyka C++ Do obsługi myszy zdefiniujemy klasę 7 zawierającą funkcje własne: 2 (do uru- chomienia myszy), 43 (do ujawniania kursora myszy), 96 (do ukrycia kursora myszy) i 1. (do zwrotu aktualnych współrzędnych kursora myszy). W funkcji +2 utworzymy tylko jeden obiekt o nazwie  klasy (typu) 23. Obiekt ten jest widocz- nym na rysunku 9.2a prostokątem o wymiarach zdefiniowanych za pomocą wartości argumentów w wywołaniu konstruktora klasy 23 w wierszu 49. Na rzecz tego obiektu wywołujemy funkcję własną 368 klasy 23. W funkcji tej definiujemy podokno z lokalnym układem współrzędnych, pokrywające się z utworzonym właśnie prostokątem . W tym podoknie narysujemy elipsę oraz w prawym dolnym rogu mały kwadrat, pełniący rolę uchwytu do przesuwania okna. Następnie w funkcji +2 uru- chomimy nieskończoną pętlę ;/7 8, w której sprawdzimy, czy kursor myszy znaj- duje się w polu uchwytu przesuwu i czy wtedy naciśnięty jest lewy przycisk myszy. Jeśli tak, to dotychczasowe podokno (viewport) ulega wymazaniu, a cały rysunek przerysowywany jest w nowym (wskazanym myszą) położeniu. W tym nowym poło- żeniu ponownie ustalimy lokalny układ współrzędnych (nowy viewport). Naciśnięcie klawisza Esc przerywa nieskończoną pętlę ;/ i program kończy działanie. Oto program p9_2.cpp: 2-9./78.,   2-9./-323   2-9./16+4-7   2-9./78.3   2-9./.37   @  :3.78+68(cid:30)(cid:31)  2878/6$$’86,  2816+4(cid:30)78/6’86,’ (cid:31) 0(cid:30)16+46/798(cid:30)(cid:31)16(cid:31) -46280(cid:30)6+0+(cid:31)1/8-(cid:30)(cid:31)/8(cid:30) (cid:31)   )))  @   :3. 23;+2+(cid:30)(cid:31)  0(cid:30)6/178/6,1.6:/6(cid:30) ).6:/6(cid:31) (cid:31)  -46280(cid:30)6+0+ 63/-8(cid:31)1/8-(cid:30)(cid:31)/8(cid:30) (cid:31)  2878/6$$’86,  2816+4(cid:30)78/6’86,’(cid:31)  0(cid:30)16+46/798(cid:30)(cid:31)16(cid:31)  -46280(cid:30)6+0+;23;+2+(cid:31)1/8-(cid:30)(cid:31)/8(cid:30) (cid:31)   )))   -+7723  49,-  28’$’ ’’ ’ 4’$’$4’-3’-3 ’-3 7’: ’  +’+  :3. 368(cid:30)28-37 (cid:31)  :3./; (cid:30)(cid:31)  :3.47(cid:30)03+86’03+86(cid:31)  23(cid:30)03+8’03+88’03+86’03+8,’-+6@’  28-3’28-3’28-37’28: (cid:31)   ))))))))))   -+777 138 C:AndrzejPDFABC programowania w C++ 09.doc Rozdział 9.  Grafika punktowa 139  49,--+6# 9232 #   28’’’’9’9’’9  :3.2(cid:30)(cid:31)  :3.43(cid:30)(cid:31)  + 28(cid:30) ’ ’ (cid:31)  :3.96(cid:30)(cid:31)  +28(cid:30) ’ ’ (cid:31)  :3.1.(cid:30)(cid:31)   ))))))))))))))))))))))))))))))))))))))  7   :3.+2(cid:30)(cid:31)  28’’88’66’,,’2:4 78+68(cid:30)(cid:31)   23;+2+(cid:30)(cid:31)   2(cid:30)(cid:31) 43(cid:30)(cid:31)  23(cid:30) ’ ’ ’ ’ ’$ ’ $’ (cid:31)   368(cid:30)(cid:31)  ;/(cid:30) (cid:31)   0(cid:30),8(cid:30)(cid:31)(cid:31)0(cid:30)(cid:30)1/8-(cid:30)(cid:31)(cid:31)(cid:31)1/8-(cid:30)(cid:31)  0(cid:30)(cid:31),6/+   1.(cid:30)(cid:31)  0(cid:30)  K     K   (cid:31)       9 92:4   ;/(cid:30) 9 (cid:31)  0(cid:30)2:4(cid:31) /; (cid:30)(cid:31)2:4    1.(cid:30)(cid:31)  0(cid:30) (cid:31)   K(cid:30) K(cid:31)88 K(cid:30) $K(cid:31)66 S,, S  0(cid:30) (cid:31)   0(cid:30)88 (cid:31)88   0(cid:30)66 +(cid:31) +K   0(cid:30),, +(cid:31)88 +K $    $88  S   $S $   /; (cid:30)(cid:31)    0(cid:30)  9(cid:31) 368(cid:30)(cid:31)    1/8-(cid:30)(cid:31) 96(cid:30)(cid:31)-37/16+4(cid:30)(cid:31)   )))))))))))))))))))))))))))))))))))))))   2323(cid:30)03+8’03+88’03+86’03+8,’  28-3’28-3 ’28-3 7’28: (cid:31)  -3(cid:30)-3(cid:31)’-3 (cid:30)-3 (cid:31)’-3 7(cid:30)-3 7(cid:31)’: (cid:30): (cid:31)’  +1/8+(cid:30)(cid:31)+1/8+(cid:30)(cid:31)  @+$8@+ 6@+,@+    K$K$ 4  $4$    )))   :3.23 368(cid:30)28-37(cid:31)  7/8:/;4368(cid:30)’$’ ’’: (cid:31)  28-3(cid:30)-37(cid:31)-3 7-3   7/8078/(cid:30)#)’-3(cid:31)   96(cid:30)(cid:31),+6(cid:30) ’ ’ ’$(cid:31)47(cid:30) ’ (cid:31)  7/8078/(cid:30)#)’ (cid:31)  ,+6(cid:30) K ’$K ’ ’$(cid:31)  746280(cid:30) #’.’.’ ’ (cid:31)  7/8078/(cid:30)#)’ (cid:31)  ,+6(cid:30)’’’ (cid:31)3988/8(cid:30)’’ #(cid:31)   43(cid:30)(cid:31) C:AndrzejPDFABC programowania w C++ 09.doc 139 140 Czlć I  Wprowadzenie do jzyka C++   )))   :3.23/; (cid:30)(cid:31)   96(cid:30)(cid:31)-/+6:/;4368(cid:30)(cid:31) 43(cid:30)(cid:31) 368(cid:30) (cid:31)    :3.2347(cid:30)03+86’03+86(cid:31)  7/8078/(cid:30)#)’-3(cid:31) 0/47/(cid:30) 4’$4’6@ 4’6@$4(cid:31)  )))  :3.72(cid:30)(cid:31)    + 28(cid:30) ’ ’ (cid:31)0(cid:30)  + (cid:31)  -46280(cid:30)2+278+97(cid:31)1/8-(cid:30)(cid:31)/8(cid:30) (cid:31)  1.(cid:30)(cid:31)     :3.71.(cid:30)(cid:31)    +28(cid:30) ’ ’ (cid:31)  -  . 9(cid:30)  ,  (cid:31)   (cid:30)(cid:31)  9(cid:30)99(cid:31)    0(cid:30)(cid:31)   W wierszu 7. widzimy początek funkcji 78+68 uruchamiającej grafikę bez dołączania sterowników z BGI. Funkcja ta jest tu nieczynna z powodu objęcia jej ciała znakami (cid:15)(cid:15) . W wierszu 15. widzimy początek definicji funkcji  23;+2+ inicjalizującej tryb graficzny z trwałym dołączeniem sterownika EGAVGA z BGI. Ta funkcja jest tu aktywna. Przed kompilacją programu należy utworzyć plik Bgiobj.obj (jak w progra- mie p9_1gw.cpp) i dołączyć go do listy węzłów (node) w oknie Project. W wierszu 24. widzimy początek definicji klasy 23. Składnikami własnymi tej klasy są współrzędne przeciwległych wierzchołków okna lokalnego oraz jego wymiary. Zmienne + i + przechowywać będą informację o maksymalnych wartościach współrzędnych ekranu w poziomie i w pionie w aktualnym trybie karty graficznej. W wierszu 28. funkcja 368, ustalająca okno lokalne, posiada jeden argument z warto- ścią domniemaną -37 . Wartość 1 tego argumentu spowoduje wybranie dla okna lokalnego alternatywnego koloru (wtedy, gdy okno to podlega przesuwaniu w inne miejsce). Realizuje to funkcja /; w wierszu 95., wywołująca funkcję 368 z pa- rametrem -37 . Jednakże, gdy nie ma przesuwania okna, wybierany jest zwykły kolor określony zmienną -3, co odpowiada podanej wartości domniemanej zmiennej -37 równej zero. Deklarację funkcji własnej /; widzimy w wierszu 29., a jej definicję w wierszu 95. Przed narysowaniem nowego okna wywoływana jest funkcja -/+6:/;4368 czysz- cząca okno dotychczasowe. Funkcja -/+6./:-/ wyczyściłaby cały ekran. W wierszu 32. widzimy deklarację konstruktora klasy 23. W wierszu 35. widzimy początek klasy 7 zapewniającej obsługę myszy. Składnik własny w postaci tablicy znakowej # służyć będzie do formatowania wydruku (za pomocą funkcji 746280) z aktualnymi współrzędnymi myszy. Składniki ,  przechowują współrzędne aktualne, a  i  współrzędne poprzednie kursora myszy. Składniki 9 i 9 podają informację o aktualnym i poprzednim naciśnięciu lewego przycisku myszy. Jeśli nastąpiła zmiana 140 C:AndrzejPDFABC programowania w C++ 09.doc Rozdział 9.  Grafika punktowa 141 współrzędnych lub zmiana stanu naciśnięcia przycisku myszy, to składniki  lub 9 wynoszą jeden. Funkcja 2 zadeklarowana w wierszu 38. jest zdefiniowana w wier- szu 102. i następnych. W ciele tej funkcji widzimy wywołanie funkcji 0H przerwania 33H oraz sprawdzenie poprawności inicjalizacji. Ewentualne niepowodzenie powoduje wydruk łańcucha +2-+97. Należy wtedy odszukać w zasobach komputera np. funkcję msmouse.com i ją wykonać. Można wtedy ponownie przystąpić do wyko- nania programu p9_2.exe. W wierszu 39. podano deklarację i definicję funkcji 43 ujawniającej kursor myszy. Funkcja ta wywołuje funkcję 1H przerwania 33H. Ukrywanie kursora myszy zapewnia funkcja 96 z wiersza 40. Wywołuje ona funkcję 2H przerwania 33H. W wierszu 41. widzimy deklarację funkcji 1. dostarczającej informacji o aktualnym położeniu myszy. Jej definicja znajduje się w wierszu 108. i następnych. Wywołuje ona funkcję 3H przerwania 33H. Przerwanie to zwraca współrzędne myszy w rejestrach CX i DX . Informacja o stanie przycisku myszy w chwili wywoływania przerwania znajduje się w rejestrze BX. Informacje te przekazywane są do składników własnych klasy 7. W wierszu 111. ustalane są składniki niosące informację o tym, czy współ- rzędne myszy się zmieniły, lub czy zmienił się stan naciśnięcia przycisku myszy. W wierszu 43. (jeszcze przed +2) definiowany jest obiekt  klasy 7. Obiekt ten ma zasięg globalny, gdyż jest zdefiniowany poza ciałem jakiejkolwiek funkcji. W wierszu 46. widzimy wywołanie funkcji 78+68, z tym że jest ono nieaktywne (po dwóch ukośnikach —znakach slasz). Aktywne jest wywołanie funkcji  23;+2+ w wierszu 47. W wierszu 48. inicjalizujemy i ujawniamy mysz. W wierszu 49. kreowany jest obiekt  klasy 23 poprzez wywołanie konstruktora tej klasy. Na liście parametrów aktual- nych podajemy współrzędne względne globalne (odnoszące się do całego ekranu) wierzchołków lewego górnego i prawego dolnego okna lokalnego. Na rzecz tego obiektu w wierszu 50. wywoływana jest funkcja 368 ustalająca lokalny układ współ- rzędnych. W wierszu 51. zaczyna się zasadnicza część programu w postaci nieskończonej pętli ;/7 8. W wierszu 52. sprawdzamy, czy bufor klawiatury jest niepusty. Jeśli tak, i jeśli naciśniętym klawiszem był klawisz Esc (o kodzie ASCII = 27), to pętla ta ulega przerwaniu, po czym następuje zakończenie programu. W wierszu 54. sprawdzamy aktualne współrzędne myszy wywołując funkcję 1. na rzecz obiektu  o zasięgu globalnym. W wierszu 55. sprawdzamy, czy kursor myszy znajduje się na prawym dolnym uchwycie do przesuwania okna. Jeśli tak, to wykonywane jest całe ciało instrukcji 0 od wiersza 55. do 68. W wierszu 57. sprawdzamy dodatkowo, czy lewy przycisk myszy jest naciśnięty. Jeśli tak, to wykonywane jest całe ciało instrukcji ;/7 9 8, od wiersza 57. do 68. W wierszu 58. wywoływana jest funkcja /; po to, aby zmienić kolor okna przy przesuwaniu. W wierszu 59. odczytujemy współrzędne bieżące myszy (w trakcie przesuwania). W wierszu 60. sprawdzamy, czy współrzędne te są inne C:AndrzejPDFABC programowania w C++ 09.doc 141 142 Czlć I  Wprowadzenie do jzyka C++ niż poprzednio. Jeśli tak, to wykonywane jest ciało instrukcji warunkowej 07 8 w wierszach 62. i 67. W wierszu 67. za pomocą funkcji /; rysowane jest okno lo- kalne, z tym że wiersze poniżej wiersza 62. zabezpieczają brzegi okna przed wyjściem poza zakres ekranu. Jeśli przycisk myszy zostanie zwolniony, to przerywana jest pętla ;/7 9 8 i w wierszu 69. funkcja 368, wywołana na rzecz obiektu , odtwarza normalny kolor okna lokalnego. Po przerwaniu pętli ;/7 8 za pomocą instrukcji ,6/+ z wiersza 52. program prze- chodzi do wiersza 71. i, po zakończeniu trybu graficznego poprzez wywołanie funkcji -37/16+4, 9/1++2 -9. W wierszu 74. widzimy definicję konstruktora klasy 23. W wierszu 77. wymiary ekranu (w pikselach) wpisywane są do zmiennych + i +. Funkcja własna 368 w wierszu 82. oczekuje na liście parametrów formalnych in- formacji o tym, czy do rysowania okna lokalnego należy używać alternatywnego ko- loru. Wartość domniemana tego parametru wynosi zero (wiersz 28.). Na jego podstawie w wierszu 84. ustalany jest kolor w zmiennej lokalnej -3. W wierszu 86. rysujemy „prostokąt” (za pomocą funkcji bibliotecznej ,+6) oraz elipsę, wywołując funkcję 47 z wiersza 98. W wierszu 88. rysowany jest uchwyt do przesuwania okna. W wierszu 89. funkcja 746280 wpisuje współrzędne myszy do łańcucha pomocniczego # w obiekcie  klasy 7. Łańcuch ten jest w wierszu 91. wyświetlany na ekranie za pomocą funkcji 3988/8. Każda operacja graficzna na ekranie powinna być wykonywana przy ukrytej na ten czas myszy. Po wykonaniu tych operacji ujawniamy mysz, jak w wierszu 92., wywołując funkcję 43 na rzecz obiektu . Po skompilowaniu, konsolidacji i uruchomieniu programu w trybie Windows lub MS- DOS otrzymujemy ekran widoczny na rysunku 9.2a. Rysunek 9.2a. Ekran programu p9_2.exe z prostokątem, elipsą, informacją o położeniu kursora i uchwytem do przesuwu całego rysunku za pomocą myszy z naciśniętym lewym przyciskiem W lewym górnym rogu okna widzimy aktualne współrzędne myszy. W prawym dolnym rogu widzimy uchwyt do przesuwania prostokątnego okna lokalnego z elipsą w jego centrum. W trakcie przesuwania okna (ciągnąc mysz zaczepioną w uchwycie) zmianie ulega kolor tła okna lokalnego, jak przedstawiono to na rysunku 9.2b. 142 C:AndrzejPDFABC programowania w C++ 09.doc Rozdział 9.  Grafika punktowa 143 Rysunek 9.2b. Ekran programu p9_2.exe w czasie przesuwania za pomocą myszy lokalnego okna w nowe położenie Zwolnienie przycisku myszy przywraca oryginalne kolory okna lokalnego. W celu za- kończenia programu należy nacisnąć klawisz Esc. Kopiowanie wycinków obrazu do pamici W wyniku wykonania programu p5_6.exe utworzony został zbiór mojPlik z kodami ASCII dziesięciu znaków. Obecnie wartości tych kodów potraktujemy jako rzędne dziesięciopunktowego wykresu z rysunku 9.3a. Plik mojPlik kopiujemy z katalogu p5_6 do katalogu bieżącego p9_3, w którym utworzymy obecny projekt dla programu p9_3.cpp — z grafiką wlinkowaną (trwale dołączoną) za pomocą znanej z poprzed- niego programu funkcji  23;+2+. W wierszu 43. utworzymy obiekt  poprzez wywołanie konstruktora klasy 23, który jest prostokątem koloru jasnoszarego ((cid:31) $ ). Na rzecz obiektu  wywołamy funkcję 368, ustalającą aktualny układ od- niesienia pokrywający się z prostokątem . Mając już układ odniesienia, wywołujemy na rzecz obiektu  funkcję 6/7. W funkcji tej stworzymy dostęp do pliku mojPlik (używając funkcji bibliotecznej 034/2) i odczytamy z tego pliku dane do wykresu. Wartości kodów ASCII kolejno odczytanych znaków stanowią rzędne dla wierzchołków linii łamanej tworzonego wykresu. Wykres utworzymy poprzez wywołanie funkcji bibliotecznej 2/ dla każdego wierzchołka linii łamanej. W wierzchołkach tych na- rysujemy małe kółka (używając funkcji bibliotecznej 4/7-/). Następnie, w +2 uruchomimy nieskończoną pętlę ;/7 8. W pętli tej sprawdzamy położenie kursora myszy i ewentualne naciśnięcie jej lewego przycisku. Jeśli kursor naprowadzimy na jeden z wierzchołków linii łamanej (na jedno z kółek) i naciśniemy przycisk myszy, to nad wskazanym wierzchołkiem pojawi się prostokąt z napisem (rysunku 9.3b) za- wierającym informację o znaku i kodzie ASCII, jakiemu odpowiada dany wierzchołek wykresu (czyli dane kółko). Po zwolnieniu przycisku myszy, napis powinien zostać usunięty, a wykres powinien przyjąć oryginalną postać. Aby nie naruszać pozostałej części wykresu, postulat ten zrealizujemy w ten sposób, że jeszcze przed wyświetleniem napisu umieścimy w pa- mięci (używając funkcji bibliotecznej 1/8+1/) oryginalny obraz prostokątnego wy- cinka ekranu, w którym za moment ma pojawić się napis. Odtworzenie wykresu (po zakończeniu wyświetlania napisu) polegać będzie na skopiowaniu w miejsce napisu ob- razu wycinka ekranu, umieszczonego uprzednio w pamięci. Zostanie to zrealizowane za pomocą funkcji bibliotecznej 498+1/. C:AndrzejPDFABC programowania w C++ 09.doc 143 144 Czlć I  Wprowadzenie do jzyka C++ Oto program p9_3.cpp: 2-9./78.,   2-9./-323   2-9./16+4-7   2-9./78.3   2-9./.37    :3. 23;+2+(cid:30)(cid:31)  0(cid:30)6/178/6,1.6:/6(cid:30) ).6:/6(cid:31) (cid:31)  -46280(cid:30)6+0+ 63/-8(cid:31)1/8-(cid:30)(cid:31)/8(cid:30) (cid:31) 2878/6$$’86, 2816+4(cid:30)78/6’86,’(cid:31)  0(cid:30)16+46/798(cid:30)(cid:31)16(cid:31)  -46280(cid:30)6+0+;23;+2+(cid:31)1/8-(cid:30)(cid:31)/8(cid:30) (cid:31)   )))   -+7723  49,-  28’$’ ’’ ’$’-3’-3 ’  +’+’0 ’ ’ ’   ’4 ’1 ’. ’;’’;  78+8-.39,/49’49-+67 :3.@4  :3. 368(cid:30)(cid:31):3.6/7(cid:30)(cid:31)  23(cid:30)03+8’03+88’03+86’03+8,’  28-3’28-3 (cid:31)   ))))))))))   -+777  49,--+6# 9232 #   28’’’’9  :3.2(cid:30)(cid:31)  :3.43(cid:30)(cid:31)  + 28(cid:30) ’ ’ (cid:31)  :3.96(cid:30)(cid:31)  +28(cid:30) ’ ’ (cid:31)  :3.1.(cid:30)(cid:31)   ))))  7  .39,/2349 ’ ’ ’ ’ ’ ’ ’  2349 ’ ’ ’ ’ ’ ’  )))))   :3.+2(cid:30)(cid:31)  28’’; +’9’: 78+68(cid:30)(cid:31)   23;+2+(cid:30)(cid:31)   2(cid:30)(cid:31) 43(cid:30)(cid:31)  23(cid:30) ’ ’ ’ ’ ’$ (cid:31)   368(cid:30)(cid:31)   6/7(cid:30)(cid:31)  ;/(cid:30) (cid:31)   0(cid:30),8(cid:30)(cid:31)(cid:31)0(cid:30)(cid:30)1/8-(cid:30)(cid:31)(cid:31)(cid:31)1/8-(cid:30)(cid:31)  0(cid:30)(cid:31),6/+   1.(cid:30)(cid:31)  036(cid:30)  SS(cid:31)  0(cid:30)    4   1   . 9(cid:31)  ; +   .30(cid:30); +(cid:31)  7/8078/(cid:30)#)’ (cid:31) 144 C:AndrzejPDFABC programowania w C++ 09.doc Rozdział 9.  Grafika punktowa 145  7/8-336(cid:30) (cid:31)  746280(cid:30) 7’-’.’ 0’ 0(cid:31)  9 K ;   : 1K K $   96(cid:30)(cid:31)  1/8+1/(cid:30)9’:’9S ;’:S ’ 4(cid:31)  ,+6(cid:30)9’:’9S ;’:S (cid:31)3988/8(cid:30)9’:’ 7(cid:31)   43(cid:30)(cid:31); +      1.(cid:30)(cid:31)  ;/(cid:30) 9(cid:31)    0(cid:30); +(cid:31)   96(cid:30)(cid:31)498+1/(cid:30)9’:’ 4’ ) $(cid:31)   43(cid:30)(cid:31); +      96(cid:30)(cid:31)-37/16+4(cid:30)(cid:31).//8/ 4 4    )))))))))))))))))))))))))))))))))))))))))))))))))   2323(cid:30)03+8’03+88’03+86’03+8,’  28-3’28-3 (cid:31)-3(cid:30)-3(cid:31)’-3 (cid:30)-3 (cid:31)  +1/8+(cid:30)(cid:31)+1/8+(cid:30)(cid:31)  @+$8@+ 6@+,@+    K$K$  036(cid:30)28 SS(cid:31)  4949@ 49(cid:30) K49(cid:31)@$  746280(cid:30)7’-’.’ + ’(cid:31)  ;8/8;.8(cid:30)7(cid:31)8/8/18(cid:30)7(cid:31)  ;+1/7/(cid:30) ’ ’;’(cid:31)42/;-+6;  0(cid:30)4(cid:31) 96(cid:30)(cid:31)-37/16+4(cid:30)(cid:31)  -46280(cid:30)2/;4(cid:31)1/8-(cid:30)(cid:31)/8(cid:30) (cid:31)   )))   :3.23 368(cid:30)(cid:31)  7/8:/;4368(cid:30)’$’ ’’ (cid:31)  7/8078/(cid:30)#)’-3 (cid:31)   96(cid:30)(cid:31),+6(cid:30) ’ ’ ’$(cid:31)  7/82/78/(cid:30)#)’ ’(cid:31)7/8-336(cid:30) $(cid:31)  036(cid:30)28 SS(cid:31)  2/(cid:30)(cid:30)28(cid:31)49K ’(cid:30)28(cid:31)49K ’  (cid:30)28(cid:31)49’(cid:30)28(cid:31)49(cid:31)  7/8-336(cid:30) (cid:31)3988/8(cid:30) ’ ’24928(cid:31)   43(cid:30)(cid:31)   ))) :3.236/7(cid:30)(cid:31)  28 ’’’’.@4034/2(cid:30)3 ’68(cid:31)  0(cid:30)4 (cid:31)  3988/8(cid:30) ’ ’3 (cid:31)1/8-(cid:30)(cid:31)/8(cid:30) (cid:31)  6/;2.(cid:30)4(cid:31)  7/8-336(cid:30)-3(cid:31)7/8078/(cid:30)#)’-3(cid:31)  0 01/8-(cid:30)4(cid:31)  .  .(cid:30) K0 (cid:31) @$     .3001/8-(cid:30)4(cid:31) (cid:30) K0(cid:31) @$  2/(cid:30)’’S.’(cid:31)4/7-/(cid:30)’’ ’ ’(cid:31)  S. C:AndrzejPDFABC programowania w C++ 09.doc 145 146 Czlć I  Wprowadzenie do jzyka C++  ;/(cid:30)SS (cid:31)  4/7-/(cid:30)’’ ’ ’(cid:31)  036(cid:30)  SS(cid:31)  SK4SS  1$SK.$SS     )))   :3.72(cid:30)(cid:31)    + 28(cid:30) ’ ’ (cid:31)0(cid:30)  + (cid:31)  -46280(cid:30)2+278+97(cid:31)1/8-(cid:30)(cid:31)/8(cid:30) (cid:31)  1.(cid:30)(cid:31)     :3.71.(cid:30)(cid:31)    +28(cid:30) ’ ’ (cid:31)  -  .  9(cid:30)  ,  (cid:31)    0(cid:30)(cid:31)   W wierszu 7. rozpoczyna się definicja funkcji uruchamiającej tryb graficzny (jak w pro- gramie p9_2.cpp). W wierszu 16. rozpoczyna się definicja klasy 23. Składniki własne tej klasy (w wierszu 18.) zawierać będą położenia i wymiary okna lokalnego. W wier- szu 19. widzimy dwie tablice na pomieszczenie współrzędnych dziesięciopunktowego (dziesięciowęzłowego) wykresu. Będą to współrzędne bezwzględne (w pikselach) w oknie lokalnym. Każdy węzeł wykresu jest kołem o promieniu równym cztery pik- sele. We wnętrzu każdego z tych kół wyróżnimy kwadrat, taki że jeśli współrzędne aktualne kursora myszy znajdą się we wnętrzu tego kwadratu, to dany węzeł uznamy za wskazany (zidentyfikowany) myszą. Lewe i prawe oraz górne i dolne brzegi takich kwadratów (dla każdego węzła) zapisane zostaną w tablicach , 4, 1 i ., w wierszu 20. W wierszu 21. widzimy tablice 49 i 49 o nie zdefiniowanych rozmiarach. W tablicach tych zapiszemy (początkowo w jednostkach względnych lokalnych) współrzędne tak dobranych punktów, że po połączeniu ich linią łamaną zostaną wyrysowane osie lokal- nego układu odniesienia (razem z półstrzałkami). Ponieważ deklaracja tych tablic po- przedzona jest deskryptorem 78+8-, więc tablice te należy zainicjalizować globalnie, poza ciałem jakiejkolwiek funkcji. Umożliwi to ustalenie rozmiarów tych tablic na etapie inicjalizacji (w wierszu 36. i następnym) na podstawie liczby wypisanych po prawej stronie elementów danej tablicy. W wierszu 21. widzimy również deklarację wskaźnika 4 obiektu typu :3., tzn. obiektu typu nie zdefiniowanego. Wskaźnik ten będzie wskazywał na uprzednio zare- zerwowany (wiersz 83.) blok pamięci (bufor) do składowania (zapisywania) pierwot- nego wyglądu (obrazu, image) wybranego wycinka prostokątnego ekranu. W wierszu 22. widzimy deklarację funkcji własnych klasy 23. Funkcja 368 zdefi- niowana jest w wierszu 85. i następnych. Odpowiada ona za wypełnienie tła (za po- mocą funkcji bibliotecznej ,+6) kolorem -3 . Ponadto, w wierszu 89., funkcja ta ry- suje osie współrzędnych okna lokalnego (używając funkcji bibliotecznej 2/). Zwróćmy uwagę na jawne konwersje typów .39,/ na typy 28 (wymagane przez funkcję 2/) bezpośrednio na liście argumentów aktualnych w wywołaniu tej funkcji w wierszu 89. Dzięki funkcji 368, na ekranie, w trybie graficznym, pojawia się napis 24928, podpowiadający co należy uczynić po uruchomieniu tego programu. 146 C:AndrzejPDFABC programowania w C++ 09.doc Rozdział 9.  Grafika punktowa 147 Funkcja 6/7 (wiersz 22.) zdefiniowana jest w wierszu 101. i następnych. W wierszu 102. funkcja ta definiuje i uruchamia wskaźnik 4 obiektu strumieniowego  obsłu- gującego dostęp do pliku 3 . Wskaźnikowi temu przypisywany jest adres zwra- cany przez funkcję 034/2. Gdyby proces otwarcia pliku (za pomocą funkcji 034/2) się nie powiódł (np. gdyby w bieżącym katalogu nie było pliku mojPlik), to wskaźnik 4 otrzymałby wartość  . Wtedy w wierszu 102. i następnych wydrukowany zostałby komunikat (jeszcze w trybie graficznym, stąd użycie funkcji 3988/8) zawierający napis 3 . Następnie program zostałby zakończony. W przypadku powodzenia otwarcia pliku mojPlik, w wierszu 105. funkcja 6/;2.748 wymusi ustawienie wskaź- nika 4 na początku tego pliku. Jest to tutaj zabieg czysto formalny, gdyż funkcja 034/2 automatycznie ustawia wskaźnik na początku otwieranego pliku. Z powyższych uwag wynika, że aby otwarcie pliku się powiodło, należy w bieżącym katalogu zapewnić obecność pliku mojPlik np. poprzez wykonanie w tym katalogu programu p5_6.exe albo poprzez skopiowanie tego zbioru z katalogu p5_6. W wierszach od 110. do 114. widzimy pętlę .3;/78. W wierszu 110. funkcja 01/8- odczytuje kolejny znak z pliku mojPlik i podstawia go do kolejnych elementów tablicy 0. W wierszu 112. funkcja 2/ kreśli kolejny odcinek wykresu (od punktu poprzedniego) do węzła, którego rzędna ma odwzorowywać wartość kodu ASCII właśnie odczytanego (z pliku) znaku. Każdy węzeł jest kołem wypełnionym. Kreśli go funkcja 4/7-/. Parametry 0 (stopni) oznaczają wypełnienie całego koła, a nie tylko jego wycinka. Ostatni parametr, wynoszący , oznacza promień (w pikselach) węzła kołowego. W wierszu 115. widzimy wywołanie funkcji 4/7-/ dla naryso- wania koła w ostatnim węźle wykresu, bowiem wewnątrz pętli .3;/78 rysowane są koła w węźle początkowym kolejnego odcinka linii łamanej. W wierszu 116. i dwóch następnych widzimy definicje kwadratów (dla każdego węzła) zapewniających łatwą identyfikację danego węzła przez mysz. Zauważmy dodanie of- fsetów  i $ w celu uzyskania wartości (bezwzględnych) globalnych, gdyż takimi wartościami operują funkcje obsługujące mysz. W wierszu 23. widzimy deklarację konstruktora klasy 23. W wierszu 27. widzimy definicję klasy 7, podobną do tej z programu p9_2.cpp. W wierszu 35. kreowany jest obiekt  (typu 7) o zasięgu globalnym — dostępny z każdej funkcji. W wierszu 41., w +2, widzimy wywołanie funkcji  23;+2+ uruchamiającej tryb graficzny. W wierszu 43. kreowany jest obiekt  klasy 23 poprzez wywołanie na jego rzecz konstruktora tej klasy. W wierszu 44. wywołujemy funkcję 368 (wiersze 22. i 85.), w wyniku czego uzy- skujemy współrzędne układu lokalnego. W wierszu 45. wywołujemy funkcję 6/7 na rzecz obiektu  (klasy 23). W wierszu 46. rozpoczyna się zasadnicza część programu w pętli nieskończonej ;/7 8. W wierszu 48. kontrolowane jest ewentualne naciśnięcie klawisza Esc (kod ASCII = 27). Po naciśnięciu tego klawisza zostanie wykonana instrukcja ,6/+. Pro- gram przerwie pętlę i przejdzie do wiersza 71. C:AndrzejPDFABC programowania w C++ 09.doc 147 148 Czlć I  Wprowadzenie do jzyka C++ W wierszach 50. i 51. (w pętli 036) sprawdzamy, czy kursor myszy znajduje się w środ- ku któregoś z dziesięciu węzłów i czy równocześnie naciśnięto lewy przycisk myszy. Jeśli tak, to wykonywane jest ciało tej instrukcji w wierszach od 53. do 71. Ponadto zmienna ; + ustalana jest na zero, gdyż w buforze pamięci wskazywanym przez wskaźnik 4 nie ma jeszcze umieszczonego żadnego wycinka obrazu ekranu. W wierszu 54. rozpoczyna się pętla .3;/78 kończąca się w wierszu 66. Jest ona wykonywana tak długo, jak długo pozostaje naciśnięty przycisk myszy. W wierszu 54. sprawdzamy, czy wycinek ekranu został już wpisany do bufora w pamięci. Jeśli jeszcze nie (dla właśnie wskazywanego węzła), to wykonywane jest ciało tej instrukcji od wiersza 55. do wiersza 63. W zakresie tego ciała, w wierszu 57., używamy funkcji 746280 do sformatowania i zeskładowania (zapisania) (w tablicy  7) wydruku będą- cego opisem węzła. W wierszu 58. ustalane są współrzędne miejsca, w którym ma zostać wydrukowany opis węzła. Wycinek ekranu, który ma być zmieniony z racji nowego wydruku, jest wcześniej pobrany z ekranu i umieszczony w buforze (przygotowanym w wierszu 84.). Odbywa się to za pomocą funkcji bibliotecznej 1/8+1/ w wierszu 61. Wycinek ekranu (którego obraz jest już umieszczony w buforze) wypełniamy w wierszu 62. prostokątem (,+6) w kolorze  , ustalonym w wierszu 55.. Na ten prostokąt, za pomocą funkcji 3988/8, nadpisywany jest opis węzła. Po zwolnieniu przycisku myszy przerwaniu ulega pętla .3;/78. Wtedy w wierszu 69. funkcja 498+1/ odtworzy prostokąt za pomocą obrazu ekranu umieszczonego w buforze, na który wskazuje wskaźnik 4. Naciśnięcie klawisza Esc powoduje przerwanie nieskończonej pętli ;/7 8 z wiersza 46. i przejście programu do wiersza 72. Zamykamy tryb graficzny i zwalniamy pamięć dynamiczną (heap), zarezerwowaną dla buforu wycinka obrazu ekranu. Ponieważ jest to tablica obiektów typu :3., więc do dealokacji pamięci używamy operatora .//8/. W wierszach od 75. do 85. widzimy definicję konstruktora klasy 23. W wierszu 81. i następnym wartości względne współrzędnych punktów do wykreślenia osi  i  lokal- nego układu odniesienia zamieniane są na wartości bezwzględne (w pikselach) lokalne. W wierszu 82. dokonujemy wpisu sformatowanego napisu wzorcowego złożonego ze znaku i trzycyfrowej liczby; późniejsze wydruki opisów węzłów nie przekroczą roz- miarów tego łańcucha. W wierszu 83. funkcje 8/8;.8 i 8/8/18 zwracają szerokość i wysokość tego wydruku. Na tej podstawie funkcja +1/7/ (w wierszu 84.) zwraca rozmiar pamięci potrzebnej na bufor do przechowywania obrazu prostokątnego wycin- ka ekranu o rozmiarze takim, jak rozmiar napisu wzorcowego. Rozmiar bufora poda- wany jest w bajtach, stąd typ :3. dla bufora. W wierszu 84. operator 2/; dokona rezer- wacji pamięci na bufor obrazu wycinka ekranu. Ewentualne niepowodzenie przydziału pamięci dynamicznej spowoduje wykonanie instrukcji z wiersza 85. i następnego. Funkcja własna 2 z wiersza 122. inicjalizuje mysz (jak w programie p9_2.cpp). Funkcja własna 1. z wiersza 128. zwraca informację o aktualnym położeniu kursora myszy (, ) oraz o stanie naciśnięcia lewego przycisku (9). 148 C:AndrzejPDFABC programowania w C++ 09.doc Rozdział 9.  Grafika punktowa 149 Po skompilowaniu, konsolidacji i wykonaniu programu w trybie Windows lub MS-DOS otrzymujemy ekran widoczny na rysunku 9.3a. Rysunek 9.3a. Fragment ekranu programu p9_3.exe z wykresem utworzonym na podstawie pliku mojPlik (z programu p5_6) Program p5_6.exe wpisał do pliku mojPlik ciąg znaków: +, ,, -, , , , , , , , którym odpowiadają kody ASCII wynoszące: 97, 98, 99, 61, 49, 50, 51, 10, 52, 52. Rzędne ko- lejnych węzłów na powyższym rysunku odpowiadają wartościom powyższych kodów ASCII tych znaków. Jeśli wskazać kursorem myszy jeden z węzłów i nacisnąć lewy przycisk, to nad wska- zanym węzłem pojawi się jego opis złożony ze znaku, przecinka oraz wartości kodu ASCII tego znaku, co widać na rysunku 9.3b. Rysunek 9.3b. Fragment ekranu programu p9_3.exe z informacją dotyczącą znaku (i jego kodu ASCII) ukrytego we wskazanym za pomocą myszy punkcie wykresu Mysz wskazuje węzeł czwarty, stąd opis zawiera znak równości o wartości kodu ASCII wynoszącej 61. W celu zakończenia programu należy nacisnąć klawisz Esc. C:AndrzejPDFABC programowania w C++ 09.doc 149
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

ABC programowania w C++
Autor:

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