TOC \o "1-4" \h \z
Rozdzia³ . Pierwsze spotkanie ze orodowiskiem Borland C++Builder 5
Parê po¿ytecznych skrótów nazw
Inspektor obiektów - Object Inspector
Karta w³aociwooci - Properties
Karta obs³ugi zdarzeñ - Events
Rozdzia³ Borland C++Builder 5. Pierwsze kroki
Ogólna postaæ programu pisanego w C++
Dyrektywa #include i prekompilacja
Podstawowe typy danych oraz operatory arytmetyczne
Æwiczenia do samodzielnego wykonania
Operatory relacyjne i logiczne
Æwiczenie do samodzielnego wykonania
Æwiczenie do samodzielnego wykonania
Æwiczenie do samodzielnego wykonania
Æwiczenie do samodzielnego wykonania
Æwiczenie do samodzielnego wykonania
Æwiczenie do samodzielnego wykonania
Æwiczenie do samodzielnego wykonania
Rozdzia³ 4. Projektowanie obiektowe OOD
Programowanie zorientowane obiektowo
Formularz jako zmienna obiektowa
Ogólna postaæ aplikacji w C++Builder 5
Wykorzystujemy w³asn¹ strukturê
Æwiczenie do samodzielnego wykonania
Æwiczenie do samodzielnego wykonania
Rozdzia³ 5 Podstawowe elementy biblioteki VCL
Wykorzystanie pozosta³ych komponentów karty Standard
Komponenty TRadioGroup oraz TScrollBar
Komponenty TMainMenu oraz TPopupMenu
Æwiczenie do samodzielnego wykonania
Hierarchia w³asnooci obiektów W³aociciele i rodzice
Æwiczenie do samodzielnego wykonania
Przyk³ad wykorzystania komponentów TApplicationEvents oraz TTimer
Æwiczenie do samodzielnego wykonania
Wykorzystanie komponentów TDirectoryListBox, TFileListBox, TFilterComboBox oraz TDriveComboBox
Wykorzystanie komponentów TCSpinEdit, TTrayIcon, TImageList oraz TCheckBox
Komponenty TPowerPointApplication, TWordApplication oraz TExcelApplication
Rozdzia³ 7 Aplikacje SDI oraz MDI
Jeden z najnowszych produktów firmy Borland/Imprise C++Builder 5 reprezentuje niezwykle bogate i bardzo wydajne
orodowisko programistyczne. [EK1]Zapoznanie siê z nowym Builderem mo¿e te¿ stanowiæ
pretekst do pokazania Czytelnikom pewnych elementów wspó³czesnych metod
programowania aplikacji. W zamierzeniu ksi¹¿ka ta przeznaczona jest dla osób
dopiero zaczynaj¹cych przygodê z programowaniem obiektowym. W jej trakcie
bêdziemy stopniowo poznawaæ niezwykle bogate orodowisko programistyczne oferowane [EK2]nam przez Buildera 5. Jjednoczeonie
zapoznamy siê z najbardziej podstawowymi elementami oraz metodami konstrukcji
algorytmów w³aociwymi dla Borland C++, tak by w efekcie w pewnym momencie
uowiadomiæ sobie, ¿e oto zaczynamy samodzielnie tworzyæ aplikacje przy pomocy
Borland C++Buildera 5 jako ca³ooci. Poznamy strukturê programów pisanych
zarówno w C++ jak i C++Builderze, a tak¿e zaznajomimy
siê z pojêciem klasy oraz obiektu formularza. Wa¿nym celem ksi¹¿ki jest
zaciekawienie Czytelnika i zachêcenie go do przyjêcia postawy eksploracyjnej, tak
niezbêdnej we wspó³czesnym Oowiecie.
Nie bêdzie naszym zadaniem przedstawienie skomplikowanych technik
zwi¹zanych z algorytmizacj¹ programów oraz stosowaniem wyszukanych funkcji,
struktur czy innych obiektów tak charakterystycznych dla wspó³czesnego C++.
Skoncentrujemy siê natomiast na poznaniu orodowiska programisty [EK3]oferowanego przez C++Buildera 5 wraz z podstawowymi elementami
biblioteki VCL. G³ówny nacisk zostanie po³o¿ony na umiejêtnooæ wykorzystania
ju¿ istniej¹cych obiektów, tak aby nawet zaczynaj¹cy sw¹ przygodê ze
wspó³czesnym C++ Czytelnik nie czu³ siê zagubiony w g¹szczu skomplikowanych
terminów i aby w trakcie ca³ej ksi¹¿ki mia³ wyraYny przegl¹d sytuacji.
Wykonuj¹c proste æwiczenia nauczymy siê pos³ugiwaæ w³aociwoociami, zdarzeniami
oraz metodami ró¿nych komponentów. Zamieszczone w ksi¹¿ce przyk³ady kompletnych
aplikacji pomog¹ nam zrozumieæ, jak z prezentowanych komponentów mo¿emy
skorzystaæ w praktyce. Ksi¹¿ka ta nie zak³ada znajomooci wczeoniejszych wersji
Buildera, dlatego z tego powodu,
oprócz elementów biblioteki VCL w³aociwych dla nowego Buildera
omówimy te¿ sposoby korzystania z zasobów zaadaptowanych ze starszych jego wersji, o których pliki pomocy
wyra¿aj¹ siê w sposób bardzo oszczêdny.
Najwa¿niejszym elementem nowego
Buildera jest szybki optymalizuj¹cy kompilator [EK4]Borland C++ Compiler v. 5.5. C++, zgodnie Bêd¹c
zgodnym ze wszystkimi licz¹cymi siê wersjami standardu ANSI/ISO C++ sprawia, ¿e praca z C++ Builderem staje ³a
siê jeszcze ³atwiejsza. Tradycyjnie C++ Builder dostêpny jest
w trzech wersjach ró¿ni¹cych siê stopniem zaawansowania.
G³ównym jego
zastosowaniem jest tworzenie aplikacji rozproszonych, internetowych oraz typu
klient/serwer. Wbudowane komponenty Internet Express, zawieraj¹ce
kreatory klientów internetowych bardzo u³atwiaj¹ tworzenie w pe³ni skalowalnych [EK5]aplikacji, internetowych
zdolnych dynamicznie przesy³aæ dane poprzez WWW. Programista ma do dyspozycji
jêzyki HTML 4 i XML.
Tworzenie aplikacji rozproszonych u³atwiaj¹ MIDAS, PageProducer oraz WebBroker.
ADOExpress zapewnia bardzo szybki dostêp do danych praktycznie rzecz bior¹c z
dowolnych Yróde³ Ttworzone
w ten sposób aplikacje bêd¹ dzia³aæ na ró¿nych platformach internetowych. Wiêksza
wydajnooæ pracy grup programistów zosta³a zapewniona przez TeamSource. Mamy
tutaj mo¿liwooci grupowania projektów wraz z ich jednoczesn¹ kompilacj¹
mo¿liwa jest równie¿ kompilacja w tle.[EK6]
Pos³uguj¹c siê t¹ wersj¹ mamy mo¿liwooæ szybkiego tworzenia aplikacji sieciowych poprzez wbudowane biblioteki elementów internetowych oraz perfekcyjnie zorganizowan¹ obs³ugê baz danych. Pos³uguj¹c siê technologi¹ CodeGuard mo¿na zminimalizowaæ wystêpowanie ró¿nego rodzaju b³êdów alokacji i dostêpu do pamiêci. Wykorzystanie komponentów Frame pozwala na efektywne, wizualne tworzenie komponentów biznesowych[EK7]. Budowanie aplikacji pos³uguj¹cej siê relacyjnymi bazami danych u³atwia InterBase Express.
Rozpoczêcie pracy min[EK8] jest najlepszym i najprostszym sposobem poznania C++ oraz nauczenia
siê metod wizualnego
budowania aplikacji[EK9]. Do dyspozycji mamy kilkadziesi¹t komponentów [EK10]wizualnych oferowanych przez biblioteki VCL (ang. Visual Component Library Wersja Standard
udostêpnia nam wszystkie niezbêdne zasoby interfejsu programisty[EK11] Win32[EK12] API (ang. Application Programming Interface Dziêki niej M mamy
mo¿liwooæ wykorzystywania zaawansowanych technologii obiektowych, takich jak
COM czy ActiveX. Z kolei OLE Automation [EK13]umo¿liwia naszym aplikacjom wspó³pracê z elementami pakietu MS Office,
np. Word, Excel, Power Point czy
Outlook.
Poniewa¿ zaczynamy w³aonie swoj¹
przygodê z programowaniem obiektowym po¿ytecznym
bêdzie
je¿eli zapoznamy siê z paroma najczêociej u¿ywanymi skrótami pewnych nazw, z
którymi mo¿emy siê spotkaæ czytaj¹c ró¿nego rodzaju artyku³y
Bbardzo
czêsto nazwy takie pojawiaj¹ siê te¿ w plikach pomocy udostêpnianych przez C++
Buildera 5.
OLE (ang. Object
Linking and Embedding) umo¿liwia osadzanie[EK14], ³¹czenie i wzajemn¹ wymianê ró¿nych
obiektów danych przy jednoczesnej pracy wielu aplikacji Windows (OLE 2). Je¿eli
termin obiekt danych [EK15]nie jest jeszcze dla nas zbyt
jasny, pPostaraj siê
wstawiæ poprzez schowek fragment jakiegoo arkusza kalkulacyjnego (mo¿e byæ to
tabela) pochodz¹cego np. z Excela
do pliku dokumentu edytora tekstu, np. Worda. W³aonie wWykona³eo
operacjê wymiany obiektu danych pomiêdzy dwiema niezale¿nie dzia³aj¹cymi
aplikacjami. Dane mo¿emy wymieniaæ za poorednictwem schowka DDE
ang.
Dynamic Data Exchange
czyli mechanizmu dynamicznej wymiany danych lub du¿o bardziej wydajnego,
jednolitego transferu danych UTD (ang. Uniform Data Transfer)
lub te¿ na zasadzie zwyk³ego przeci¹gania. W
¿argonie informatycznym tê ostatnio wymienion¹ operacjê okreolono by mianem drag
and drop. W dos³ownym t³umaczeniu brzmi to trochê
zabawnie: zawlec (ang. drag) i
zrzuciæ (ang. drop [EK16]
Jest czêoci¹ standardu OLE 2. Umo¿liwia zapisywanie w aplikacji sekwencji dzia³añ OLE w postaci ci¹gu poleceñ, które dany program ma zinterpretowaæ.
Component
Object Model jest standardem pozwalaj¹cym
wspó³dzieliæ obiekty z pomiêdzy wielomae
aplikacjami. i. Okreola te¿
zasady komunikacji pomiêdzy obiektami. Obiekty takie musz¹ byæ rozró¿nialne ju¿
na poziomie systemu operacyjnego. Z regu³y reprezentowane s¹ w postaci plików
wykonawczych z rozszerzeniem .exe lub bibliotek z rozszerzeniem
.dll. Pewnym uogólnieniem COM jest technologia DCOM (ang. Distributed
COM) pozwalaj¹ca wykorzystywaæ obiekty fizycznie znajduj¹ce siê na innych
komputerach po³¹czonych w sieæ.
Umo¿liwia
wspó³dzielenie obiektów z przez wielomae
aplikacjami, i jak równie¿
umieszczanie obiektów ich w sieci
Internet.
Zintegrowane orodowisko
programisty [EK19]stanowi zbiór wszystkich niezbêdnych narzêdzi pomocnych w b³yskawicznym
projektowaniu i uruchamianiu aplikacji. W sk³ad IDE wchodz¹
nastêpuj¹ce g³ówne elementy: Zasadnicze elementy, które
wchodz¹ w sk³ad IDE to:
G³ówne menu.
Pasek narzêdzi.
G³ówny formularz.
Okno edycji kodu.
Inspektor obiektów (ang. Object Inspector).
Odrêbn¹ grupê
narzêdzi pomocnych w szybkim tworzeniu aplikacji stanowi¹ paleta komponentyów
VCL. Jednak ze wzglêdu na swoje znaczenia zostan¹ one omówione w osobnym
rozdziale. zdecydujemy
siê poowiêciæ jej osobny rozdzia³.
Po uruchomieniu programu
C++Builder 5 okno monitora powininno en
wygl¹daæ podobnie jak na rysunku 1.1. Mo¿e zdarzyæ siê i taka sytuacja, ¿e
formularz o nazwie Form1 nie pojawi siê od razu, wówczas nale¿y z g³ównego menu
wybraæ opcjê File|New Application
Rys. 1.1. |
|
Centraln¹ czêoæ monitora zajmowaæ bêdzie obszar zwany formularzem (w bardziej zaawansowanych opracowaniach obszar ten okreola siê mianem obszaru klienta), którego nazwa domyolnie przyjmowana jest jako Form1 (formularz, forma 1). Formularz posiada wszystkie cechy standardowego okna Windows. Ju¿ w tym momencie mo¿emy uruchomiæ nasz¹ aplikacjê naciskaj¹c chocia¿by przycisk F9. Na pewno zauwa¿ymy, ¿e po uruchomieniu tego programu zachowuje siê on tak samo jak ka¿da aplikacja Windows.
Rys. 1.2. Elementy standardowego formularza C++ Buildera |
|
Je¿eli ktoo dokona³
swojego pierwszego historycznego uruchomienia aplikacji, niech jak
najszybciej j¹ zamknie klikaj¹c oczywiocie w pole zamkniêcia. Ju¿ nied³ugo
nauczymy siê umieszczaæ na formularzu ró¿ne komponenty, ale tymczasem tym czasem
wyka¿my siê odrobin¹ cierpliwooci.
Aby dostaæ siê do
kodu g³ównego modu³u formularza wystarczy dwa razy go klikn¹æ
na
nim dwa razy.
Ujrzymy wówczas okno edycji kodu podobne do pokazanego na rysunku 1.3.
Rys. 1.3. Okno edycji kodu |
|
Byæ mo¿e powy¿sze zapisy jeszcze niewiele nam mówi¹, ale stopniowo bêdziemy je rozszyfrowywaæ. W³aonie tutaj bêdziemy pisaæ teksty naszych programów. Nale¿y jednak pamiêtaæ, ¿e ka¿da nauka programowania w Windows musi rozpocz¹æ siê od poznawania orodowiska, w którym przyjdzie nam pracowaæ, w naszym wypadku - C++Buildera 5.
Rys. 1.4 G³ówne menu |
|
Korzystaj¹c z Menu File mamy do dyspozycji nastêpuj¹ce opcje:
Rys. 1.5. Menu File |
|
Polecenie tworzy nowy projekt, formularz, okno dialogowe lub otwiera przyk³adowe projekty aplikacji - opcja File|New|Projects
Polecenie utworzenia nowego projektu. Nowo powsta³y projekt sk³ada siê z pustego formularza o nazwie Form1 oraz odpowiadaj¹cego mu modu³u o nazwie Unit1.cpp.
Polecenie Uutworzeniae
nowego, pustego formularza.
Polecenie utworzenia nowej ramki.
Polecenie otwarcia modu³u, obiektu lub projektu. Katalogiem domyolnym bêdzie katalog, w którym zainstalowany jest Builder.
Polecenie otwarcia zapisanego wczeoniej na dysku projektu.
Wyowietlenie Zostaje
wyowietlona listy a ostatnio
u¿ywanych projektów, z których ka¿dy mo¿na natychmiast otworzyæ.
Polecenie zapisania bie¿¹cego modu³u na dysku. Domyolnie plik ten bêdzie mia³ rozszerzenie *.cpp.
Zapisanie Zapisuje
wybranego
y modu³u pod now¹
nazw¹. Zawsze dobrym zwyczajem jest zapisywanie kolejnych modu³ów pod innymi
nazwami.
Polecenie zapisania aktualnie u¿ywanego projektu pod inn¹ nazw¹.
Zapisanie na dysku wszystkich aktualnie otwartych plików C++Buildera.
Zamkniêcie aktualnie u¿ywanego modu³u kodu *.cpp wraz z odpowiadaj¹cym mu formularzem.
Zamkniêcie yka
aktualnie otwartyego projektu.
Do³¹czenie do
aktualnie u¿ywanego modu³u kodu nowego pliku nag³ówkowego. Je¿eli aktualnie
pracujemy z formularzem Form2, któremu odpowiada modu³ Unit2.cpp i
zechcemy do³¹czyæ modu³ powiedzmy Unit1.cpp, wówczas u¿ycie tego
polecenia spowoduje wyowietlenie nastêpujacego okna: informacji o nastêpuj¹cej
treoci:
Rys. 1.6. Do³¹czanie nowego modu³u |
|
Okreolimy w ten sposób, czy modu³ Unit1.cpp ma byæ u¿ywany przez Unit2.cpp.
Polecenie drukowania aktualnie u¿ywanego elementu projektu. Gdy zechcemy wydrukowaæ zawartooæ okna edycji kodu pojawi siê opcja Print Selection. W przypadku drukowania formularza ujrzymy okienko Print Form
Opuszczenie C++Buildera i ewentualne zapisanie wszystkich otwartych elementów aplikacji.
Pe³ne rozwiniêcie menu edycyjnego pokazano na rysunku 1.7.
Rys. 1.7. Menu Edit |
|
Podobnie jak we wszystkich standardowych aplikacjach Windows, opcja ta pozwala na anulowanie ostatniej operacji. Je¿eli przez pomy³kê usuniêto jakio komponent z formularza u¿ywaj¹c Undelete mo¿emy cofn¹æ usuwanie.
Polecenie odwrotne w stosunku do Undelete
Umieszczanie
zaznaczonego y komponentu
lub tekstu w schowku.
Polecenie kopiowania zaznaczonego elementu do schowka. W schowku zostanie umieszczona jedynie jego kopia.
Wstawianie
uprzednio skopiowanegoy do schowka
obiektu
(tekstu,
komponentu) we wskazane miejsce pola edycji
kodu lub formularza.
Usuwanie Zzaznaczonegoy
obiektu.
zostanie
usuniêty. Operacja odwrotna mo¿liwa jest przy u¿yciu Undelete
W przypadku edycji
kodu Yród³owego zaznaczeniea
ca³egoy
tekstu.
W przypadku formularza zaznaczeniea
wszystkiche znajduj¹cyche
siê tam komponentówy.
Przy pomocy tego
polecenia dopasowujemy po³o¿enia wszystkich elementów sk³adowych formularza do
jego siatki. Operacja ta bêdzie dawaæ widoczne efekty, pod warunkiem
odznaczenia opcji Snap to Grid w menu Tools|Environment Options|Preferences
Zaznaczony element komponent
nie bêdzie ewentualnie przykrywany przez inne znajduj¹ce
siê w
na formularzu. Element Komponent
taki bêdzie zawsze ca³kowicie widoczny.
Polecenie odwrotne do Bring to Front
Wywo³anie polecenia w stosunku do uprzednio zaznaczonego komponentu umo¿liwia dopasowanie i wyrównanie jego po³o¿enia na formularzu. [EK21]
Umo¿liwia Ddok³adne
ustalenie rozmiaru obiektu. komponentu.
Operacja ta mo¿e byæ z powodzeniem u¿yta w stosunku do uprzednio zaznaczonej
grupy obiektów.komponentów
Polecenie
przeskalowania formularza jako ca³ooci wraz ze wszystkimi elementami
komponentami wchodz¹cymi w jego sk³ad.
Pisz¹c aplikacje do
Windows w wielu wypadkach staramy siê uniezale¿niæ od dzia³ania myszki. Istnieje
mo¿liwooæ ustalenia kolejnooci przechodzenia pomiêdzy sk³adnikami formularza komponentami
przy u¿yciu klawisza Tab. Polecenie Tab Order wyowietla okienko dialogowe pokazane na rys. 1.8. U¿ywaj¹c przycisków
opatrzonych strza³kami mo¿na w prosty sposób ustaliæ kolejnooæ przechodzenia
pomiêdzy wszystkimi aktualnie dostêpnymi elementami komponentami,
które wchodz¹ w sk³ad projektowanego formularza.
Rys. 1.8. Okno dialogowe Edit Tab Order |
|
Opcja pozwalaj¹ca ustaliæ kolejnooæ tworzenia tzw. komponentów niewidocznych (przestaj¹ byæ widoczne w momencie uruchomienia aplikacji).
Umo¿liwienie a
automatycznej zamiany
kolejnooci u³o¿enia poszczeólnych czêoci komponentów
na formularza. u.
Wybieraj¹c tê
opcjê zablokujemy mo¿liwooæ przemieszczania obiektów komponentów
w obrêbie formularza tworzonej aplikacji. Wybranie Lock Controls zapobiega przypadkowej
zmianie po³o¿enia ju¿ wybranego obiektu. komponentu.
Pokazane w rozwiniêciu na rys. 1.9 menu Search zawiera nastêpuj¹ce opcje:
Rys. 1.9. Menu Search |
|
Opcja pozwalaj¹ca wyszukaæ
Wyszukanie
w kodzie wybranego y fragmentu
tekstu. Przy pomocy okna dialogowego Find Text okreolamy ¿¹dane parametry wyszukiwania.
Opcja ta Uumo¿liwia
przeszukiwanie plików. Przy pomocy zak³adki Find in Files okreolamy ¿¹dane parametry wyszukiwania.
Wyszukanie okreolonego tekstu lub jego fragmentu i zast¹pienie go innym.
Wyszukanie kolejnego wyst¹pienia okreolonego tekstu lub jego fragmentu.
Jest to tzw. opcja niewidoczna. Przed skorzystaniem z jej us³ug najlepiej jest ustawiæ kursor na samym pocz¹tku tekstu kodu. Po wybraniu Search|Incremental Search nale¿y zacz¹æ pisaæ szukane s³owo. Builder odczyta pierwsz¹ literê i natychmiast przeniesie kursor do pierwszego napotkanego w tekocie zwrotu zawieraj¹cego wpisan¹ literê.
Przeniesienie kursora do wskazanego wiersza kodu.
Opcja dostêpna w trakcie dzia³ania aplikacji. Umo¿liwia krokowe sprawdzanie wartooci zmiennych, rejestrów CPU itp. Po pojawieniu siê okienka dialogowego, podobnego do pokazanego na rys. 1. nale¿y wpisaæ ¿¹dan¹ wartooæ. Liczby heksadecymalne nale¿y poprzedziæ par¹ znaków 0x
Rys. 1. |
|
Potwierdzaj¹c
przyciskiem OK. zobaczymy okno
aktualnego stanu m.in. m. in.
rejestrów CPU (ang. Central Processing Unit) czyli jednostki
centralnej lub po prostu procesora. Poruszanie siê w oknie CPU mo¿liwe jest dziêki kombinacji
klawiszy Ctrl (prawa/lewa) strza³ka
Rys.
1. |
|
Przedstawione na rysunku 1.12 menu View zawiera nastêpuj¹ce opcje:
Rys. 1. |
|
Polecenie to Wwywo³uje
mened¿era projektów.
To Ppolecenie
wywo³uje inspektora obiektów.
Opcja umo¿liwiaj¹ca wzajemne u³o¿enie i dopasowanie komponentów na formularzu. Jest to graficzny odpowiednik opcji Edit|Align
U¿ycie tego polecenia powoduje uaktywnienie okna (rys. 1.13 ) zawieraj¹cego wszystkie aktualnie dostêpne komponenty. S¹ one u³o¿one w porz¹dku alfabetycznym. Za pomoc¹ przycisku Add to form dowolny komponent mo¿na dodaæ do formularza.
Rys.
1. |
|
U¿ycie tego polecenia powoduje uaktywnienie dialogu, w którym pokazana jest lista aktualnie otwartych okien (rys. 1.14 ). Zaznaczaj¹c odpowiedni¹ pozycjê mo¿na przenieoæ siê do wybranego okna.
Rys.
1. |
|
W sk³ad Debug Windows wchodzi lista poleceñ pokazana na rysunku 1.15
Rys. 1. |
|
Breakpoints wyowietla
listê pu³apek (ang. breakpoint) pomocnych w oledzeniu programu korzystaj¹c
z debuggera, czyli programu uruchomieniowego. [EK22]Przy pomocy tego programu którego mamy
mo¿liwooæ pracy krok po kroku krokowej oraz mo¿liwooæ sprawdzania e
wartooci zmiennych i rejestrów procesora.
Call Stack opcja u³atwiaj¹ca ustalenie kolejnooci wywo³ywania funkcji g³ównego programu podczas dzia³ania programu uruchomieniowego.
Watches wyowietla okno Watch List, w którym mo¿na ogl¹daæ aktualne wartooci wyra¿eñ lub zmiennych. Stosowana jest podczas operacji oledzenia wykonywania programu.
Threads W okienku Thread Status pojawi siê lista aktualnie uruchomionych w¹tków.
CPU wyowietla okienko aktualnego stanu CPU. Opcja ta jest aktywna w czasie dzia³ania programu.
U¿ycie tego plecenia umo¿liwia skonfigurowanie i zapisanie pod wybran¹ nazw¹ wymaganego przez u¿ytkownika wygl¹du pulpitu (ang. desktop). Opcje tego podmenu pokazane s¹ na rysunku 1.16
Rys.
1. |
|
Mo¿liwooæ prze³¹czenia (ang. toggle) pomiêdzy edycj¹ formularza a odpowiadaj¹cym mu oknem edycji kodu (por. rysunki 1.1 oraz 1.3).
Polecenie to Ppodaje
listê wszystkich modu³ów nale¿¹cych do projektu.
Ogólnie rzecz
bior¹c, w sk³ad aplikacji mo¿e wchodziæ wiele formularzy. Przy pomcy tego polecenia
mo¿na wyowietliæ Polecenie to wyowietla listê
wszystkich formularzy u¿ywanych przez aplikacjê.
Polecenie otwarcia kolejnego okna edycji kodu. Dziêki temu mo¿emy pracowaæ z dwoma modu³ami jednoczeonie.
Mo¿liwooæ konfiguracji struktury g³ównego menu. Je¿eli wszystkie opcje Toolbars bêd¹ zaznaczone (rys. 1.17 ) to g³ówne menu bêdzie wygl¹daæ tak jak na rysunku 1.4.
Rys.
1. |
|
W sk³ad tego menu wchodz¹ nastêpuj¹ce, pokazane na rys. 1. opcje:
Rys.
1. |
|
Opcja ta umo¿liwia w³¹czenie wskazanego modu³u do projektu modyfikuj¹c automatycznie plik z opisem projektu. [EK23]
Usuwa wybrany modu³ z projektu modyfikuj¹c jednoczeonie plik g³ówny projektu.
Umo¿liwia zarejestrowanie w orodowisku Buildera wybranej biblioteki, która od tej chwili bêdzie traktowana jak ka¿da sk³adowa biblioteki VCL.
Aktualnie wykorzystywany formularz bêdzie umieszczony w repozytorium.
Polecenie edycji kodu projektu.
Polecenie edycji
wszystkich informacji dotycz¹cych zwi¹zanych z
projektu em oraz edycji
przypisañ i odwo³añ do plików i bibliotek z nim
zwi¹zanych z nim. Bêd¹
wyowietlane m.in. m. in.
informacje o orodowisku, kompilatorze, standardzie kodu, nazwie pliku
wynikowego itp.
Zapisanie pliku do kompilacji projektu (tzw. pliki makefile). Plik taki sk³ada siê z ci¹gu znaków ASCII i zawiera zestaw instrukcji do kompilacji projektu.
Polecenie tworzy nowy projekt w grupie projektów. Opcja ta dzia³a podobnie jak View|Project Manager|New
Przy pomocy tego polecenia
mo¿na dodaæ Dodaje do grupy projektów projekt ju¿
istniej¹cy i zapisany wczeoniej na dysku.
Kompilacja modu³u projektu.
Kompilacja aktualnego projektu w tzw. trybie Make. Kompilator kompiluje kody Yród³owe wszystkich modu³ów wchodz¹cych w sk³ad projektu, w których dokonano zmian od czasu ostatniej kompilacji. [EK24]Na dysku w aktualnym katalogu zostanie utworzony program wykonywalny.[EK25]
Polecenie kompilacji aktualnego projektu w tzw. trybie Build. Kompilowane bêd¹ wszystkie modu³y niezale¿nie od tego czy by³y ostatnio modyfikowane, czy nie. Na dysku w aktualnym katalogu zostanie utworzony plik wykonywalny.
Podaje informacje na temat ostatnio skompilowanego projektu, liczba linii, rozmiar w bajtach: danych, rozmiar kodu, rozmiar pliku wykonywalnego, itp.[EK26]
Kompilacja w trybie Make wszystkich projektów wchodz¹cych w sk³ad grupy projektów.
Kompilacja w trybie Build wszystkich projektów wchodz¹cych w sk³ad grupy projektów.
Polecenie wywo³ania okna dialogowego Project Options, w którym mo¿na ustaliæ parametry kompilatora i konsolidatora.
Wymienione menu zawiera opcje pokazane na rysunku 1.19.
Rys. 1. Opcje Menu Run |
|
Polecenie dokonania kompilacji (je¿eli jest to wymagane) z jednoczesnym uruchomieniem aplikacji.
Polecenie to wyowietla okno dialogowe (rys. 1.20 ), w którym mo¿na ustaliæ parametry wywo³ania aplikacji.
Rys. 1. Okno umo¿liwiaj¹ce wpisanie parametrów wywo³ania programu |
|
Uruchomienie aplikacji w trybie krokowym z mo¿liwooci¹ oledzenia jej przebiegu wiersz po wierszu. Wywo³ania funkcji traktowane bêd¹ jako jedna instrukcja bez zagl¹dania do ich wnêtrza[EK27]
Uruchomienie
aplikacji w trybie krokowym. W momencie napotkania
wywo³ania funkcji przenosimy
siê do jej wnêtrza[EK28]
Uzupe³nienie poprzedniej opcji o mo¿liwooæ zobaczenia kolejnego wiersza kodu, który jest wykonywany.
Polecenie wykonania programu do miejsca, w którym ustawiliomy kursor. Wartooæ zmiennej mo¿na zobaczyæ u¿ywaj¹c polecenia View|Debug Windows|Watches
Krokowe oledzenie wykonywania programu do momentu uruchomienia aplikacji.
Je¿eli w czasie uruchomienia aplikacji w trybie krokowym okno edycji kodu zosta³o zamkniête, przy pomocy tego polecenia okno zostanie otwarte, zao kursor znajdowaæ siê bêdzie w wierszu, który jest aktualnie wykonywany.
Tymczasowe wstrzymanie uruchomionego programu.
Polecenie zatrzymania wykonywanego programu z jednoczesnym usuniêciem go z pamiêci.
W czasie dzia³ania debuggera
istnieje mo¿liwooæ nie tylko ogl¹dania zmiennych i parametrów, ale
równie¿ mo¿na te¿ modyfikowania
ich wartooci. Mo¿na te¿ obliczaæ wyra¿enia zawieraj¹ce te zmienne lub
parametry.
Dodanie nowej zmiennej lub parametru do listy Watches
Za³o¿enie pu³apki. Wskazany wiersz kodu zostanie podowietlony.
Pokazane na rysunku 1.21 menu posiada nastêpuj¹ce opcje:
Rys. 1. Menu Component |
|
Wywo³anie zak³adki New Component, pomocnej w utworzeniu w³asnego komponentu[EK29]
Polecenie to dodaje nowy komponent do biblioteki VCL.
Polecenie
do³¹czenia do wybranego pakietu VCL zarejestrowanego
oraz istniej¹cego obiektu ActiveX do wybranego pakietu VCL.
To
polecenie tworzy szablon komponentów. Kilka elementów komponentów
mo¿na po³¹czyæ i korzystaæ z nich tak, jakby by³y pojedynczym obiektem.
Opcja umo¿liwiaj¹ca
odpowiednie zarz¹dzanie pakietami (ang. packages), które stanowi¹
czêoæ orodowiska i z których zbudowana jest biblioteka VCL. Pakiety takie mo¿na
dodawaæ, usuwaæ, edytowaæ poddawaæ edycji ich
zawartooci, tak jak pokazuje to rys. 1. .
Rys. 1. Zarz¹dzanie pakietami do³¹czonymi do orodowiska Buildera 5 w wersji Standard |
|
Mo¿liwooæ dowolnego skonfigurowania uk³adu palety komponentów poprzez ich dodawanie, usuwanie czy umieszczanie w innych miejscach.
W sk³ad menu wchodz¹ pokazane na rys. 1. opcje:
Rys. 1. Menu Tools |
|
Opcja pomocna w okreoleniu parametrów konfiguracyjnych orodowiska.
Opcja umo¿liwiaj¹ca
okreolenie w oknie edycji wielu parametrów
konfiguracyjnych okna edycji,
takich jak: rodzaj czcionki, jej kolor, rozmiar okna itp.
Ustalenie opcji debuggera.
Repozytorium jest centralnym systemem informacji o obiektach tworz¹cych aktualny projekt. Dziêki tej opcji (rys. 1. 24 ) mo¿na obiekty takie edytowaæ, dodawaæ i usuwaæ.
Rys. 1. Repozytorium obiektów |
|
To polecenie uUmo¿liwia
odpowiednie skonfigurowanie orodowiska.
Edytor graficzny
s³u¿y
¹cy do samodzielnego projektowania
ikon, przycisków, ró¿nego rodzaju rysunków pomocnych w projektowaniu aplikacji.
Na rys. 1. pokazano
wygl¹d edytora. Zasada jego obs³ugi w niczym nie odbiega od zasady pos³ugiwania
siê takimi
aplikacjami, jak Paint czy Paint Brush.chocia¿by Paintem czy Paint
Brushem.
Rys. 1. Edytor graficzny C++Buildera w dzia³aniu |
|
Przedstawione w rozwiniêciu na rys. 1. menu posiada nastêpuj¹ce opcje:
Rys. 1. Menu Help |
|
Zawieraj¹ spisy treoci oraz pliki pomocy C++ Buildera 5 i Win32 API.[EK30]
Polecenia te [EK31]pozwalaj¹ na automatycznie po³¹czenie ze stronami WWW firmy
Borland oraz stronami poowiêconymi C++Builderowi 5.
Przytrzymuj¹c lewy klawisz Alt Napisz: DEVELOPERS
Przy pomocy zestawu opcji widocznych na rysunku 1. 27 mo¿emy zapisaæ samodzielnie skonfigurowany pulpit orodowiska C++Builder 5.
Rys. 1. Menu Desktop |
|
Zawiera listê nazw, pod którymi zapisano wygl¹d skonfigurowanych pulpitów.
Przy pomocy tego okienka dialogowego zapisujemy aktualnie skonfigurowany pulpit. Analogiczn¹ operacj¹ bêdzie View|Desktops|Save Desktop
Set debug desktop
Przy pomocy tego polecenia
mo¿na okreoliæ Zapisuje wygl¹d pulpitu podczas
uruchamiania aplikacji np. poleceniem Run|Run (F9). Analogiczn¹ operacj¹ bêdzie View|Desktops|Set
Debug Desktop
Wszystkie dane o dokonanej konfiguracji pulpitu zostan¹ zapisane na dysku w pliku z rozszerzeniem .dst.
Pokazany na rysunku 1.28 pasek narzêdzi pozwala na szybszy dostêp do najczêociej u¿ywanych poleceñ IDE Buildera. Standardowo zawiera on 16 przycisków, które s¹ najczêociej u¿ywane przez programistów. Przyciski te pogrupowane s¹ w czterech obszarach (por. rys. 1.27):
Standard
View
Debug
Custom
Oczywiocie, dostêp do ka¿dego z nich mo¿liwy jest równie¿ z poziomu g³ównego menu.
Rys. 1. Pasek narzêdzi |
|
Inspektor obiektów jest bardzo
wa¿n¹ czêoci¹ IDE. Pos³uguj¹c siê nim mo¿emy bardzo szybko ustalaæ i zmieniaæ
cechy obiektów. Mo¿emy Umo¿liwia te¿ w
wygodny sposób zarz¹dza nie i edytowaæ cjê
metody[EK33] stanowi¹ce ych odpowiedY
na okreolone zdarzenie. Zasadnicz¹ czêoci¹ inspektora obiektów s¹ dwie
zak³adki, czyli karty: karta w³aociwooci cech
(ang. properties) oraz karta
obs³ugi zdarzeñ (ang. events).
Karta w³aociwooci Ppokazana
jest na rysunku 1.38. Umo¿liwia ona wygodne edytowanie w³aociwooci samego
formularza oraz aktualnie zaznaczonego na nim obiektu znajduj¹cego siê na formularzu. Ju¿ teraz
mo¿emy zmieniæ wiele cech formularza pokazanych na rysunku 1.2.
Raz klikaj¹c na w obszarze
formularza wywo³amy ujrzymy w
inspektora ze obiektów wszystkie
jago cechy. Je¿eli teraz zechcemy zmieniæ nazwê
formularza wystarczy jego cesze Caption przypisaæ w³asn¹ nazwê. Podobnie korzystaj¹c z cechy Icon mo¿emy w prosty sposób zmieniæ ikonê formularza. W³asn¹, oryginaln¹
ikonê mo¿emy stworzyæ przy pomocy edytora graficznego pokazanego na rys. 1.25.
Niektóre w³aociwooci poprzedzone
s¹ znaczkiem . Oznacza to, ¿e
zawieraj¹ szereg zagnie¿d¿onych[EK34] opcji. Dla przyk³adu rozpatrzmy cechê BorderIcons.
Klikaj¹c na zobaczymy kilka , ¿e
sk³ada siê ona z kilu pozycji. Przypiszmy cesze biMinimize wartooæ false, a nastêpnie poleceniem Run|Run lub F9 spróbujmy uruchomiæ uruchommy
aplikacjê. Pole minimalizacji stanie siê wówczas nieaktywne. Podobnie cechom biSystemMenu oraz biMaximize mo¿emy przypisaæ wartooci false jednak wówczas po uruchomieniu formularza bêdziemy mieli problem z jego
zamkniêciem (pole zamkniêcia jest wygaszone -
nieaktywne). W tego typu wypadkach nale¿y u¿yæ polecenia Run|Program Reset
Mo¿emy równie¿ ju¿ teraz ustaliæ, np. kolor
obszaru klienta przy
pomocy cechy a Color, rozmiary formularza: wysokooæ i szerokooæ -
przy
pomocy cechy Height Width, a tak¿e oraz jego
po³o¿enie formularza na ekranie
przy
pomocy cechy Top Left
Rys. 1. Inspektor obiektów karta w³aociwooci (ang. Properties) |
|
Ta karta Sstanowi
drug¹ czêoæ inspektora obiektów i zawiera j¹c
listê zdarzeñ zwi¹zanych z danym obiektem. W przysz³ooci zechcemy
by program wykona³ jak¹o operacjê w odpowiedzi na klikniêcie na w
obszar jakiegoo komponentu. Wykonamy to zapewne na zasadzie obs³ugi
zdarzenia OnClick. Je¿eli
zdarzenie ma zostaæ uaktywnione w odpowiedzi na podwójne klikniêcie,
skorzystamy z obs³ugi zdarzenia OnDblClik (Double Click).
Tego rodzaju technika programowania nazywana jest programowaniem obiektowo -
zdarzeniowym i do jej idei powrócimy jeszcze w trakcie tej ksi¹¿ki.
Rys. 1. Karta obs³ugi zdarzeñ (ang. Events) inspektora obiektów |
|
W niniejszym rozdziale zapoznaliomy siê z czêoci¹ IDE, czyli orodowiska programisty [EK35]oferowanym nam przez Buildera 5. Dalsze jego elementy bêdziemy omawiaæ ju¿ przy okazji konkretnych przyk³adów wykorzystania komponentów z biblioteki VCL. Umiemy samodzielnie skonfigurowaæ dla w³asnych potrzeb pulpit, oswoiliomy siê te¿ z inspektorem obiektów oraz opcjami dostêpnymi z poziomu g³ównego menu. Przed nami C++Builder 5.
Skoro umiemy ju¿, przynajmniej teoretycznie korzystaæ z niektórych elementów orodowiska Buildera, najwy¿szy czas, aby zapoznaæ siê z jêzykiem programowania, który stanowiæ bêdzie podstawê tworzonych przez nas w przysz³ooci aplikacji oraz z praktycznymi sposobami korzystania z IDE. Istnieje tylko jeden, skuteczny sposób, by tego dokonaæ napisanie w³asnego programu.
W niniejszym podrozdziale zapoznamy siê z elementami sk³adowymi programu pisanego dla Windows w jêzyku C++. Wynikiem utworzenia takiego programu, inaczej mówi¹c projektu bêdzie plik wykonawczy .exe oraz kilka innych zbiorów danych bardzo pomocnych na etapie projektowania programu.
Wykonajmy na pocz¹tek dwie proste czynnooci, mianowicie stwórzmy na
dysku dwa oddzielne katalogi (foldery). Proponujê, by nazwaæ je po prostu \Projekt01 oraz \Projekt02. W katalogach tych bêdziemy przechowywali pliki z których korzystaæ
bêd¹ nasze dwie pierwsze aplikacje. Nastêpnie
uruchommy C++Buildera 5,
Nastêpnie uruchommy C++Buildera 5. Poleceniem File|New|Console Wizard otwórzmy nowy modu³. Inspektor obiektów powinien byæ nieaktywny, natomiast na pulpicie powinno pojawiæ siê okno dialogowe podobne do tego z rysunku 2.1.
Rys. 2.1. Console Wizard |
|
W opcji Source Type zaznaczmy C++, zao w drugim panelu odznaczmy Use VCL oraz wybierzmy Console Application. Zaznaczenie tej ostatniej opcji spowoduje, ¿e nasz program bêdzie traktowa³ g³ówny formularz tak jakby by³ normalnym okienkiem tekstowym DOS. Potwierdzaj¹c przyciskiem OK od razu przejdziemy do okna (rys. 2.2), w którym bêdzie siê znajdowaæ szkielet kodu przysz³ego programu.
Rys. 2.2. Kod modu³u Unit1.cpp |
|
Chocia¿ powy¿sze zapisy byæ mo¿e dla niektórych z nas stanowiæ bêd¹ pewn¹ niewiadom¹, nie wnikajmy na razie w szczegó³y, wszystko to dok³adnie omówimy za chwilê. Tymczasem spróbujmy uzupe³niæ powy¿szy tekst, tak aby kompletny kod naszego modu³u, nazwijmy go ju¿ jako Unit01.cpp wygl¹da³ jak na wydruku 2.1. Nastêpnie zapiszmy nasz modu³ (polecenie File|Save As...) w katalogu \Projekt01\Unit01.cpp. Projekt modu³u zapiszmy poleceniem File|Save Project As... w tym samym katalogu \Projekt01\Projekt01.bpr.
Wydruk 2.1. Kod modu³u Unit01.cpp projektu Projekt01.bpr
#include <iostream.h>
#include <conio.h>
#pragma hdrstop
int main()
Teraz spróbujmy uruchomiæ nasz program np. poleceniem Run|Run F9). Nawet intuicyjnie poznamy, ¿e po uruchomieniu, na ekranie w okienku udaj¹cym tryb tekstowy powinien pojawiæ ciê napis: Pierwszy program w C++. Aby opuociæ program wystarczy nacisn¹æ Enter
Ka¿dy program C lub C++ musi zawieraæ w sobie
przynajmniej jedn¹ funkcjê. G³ówna funkcja main() jest t¹,
która zawsze musi istnieæ w programie. Jest wywo³ywana jako pierwsza i powinna
zawieraæ w sobie zestaw kolejnych instrukcji wykonywanych przez program, z
regu³y s¹ to wywo³ania innych funkcji. Zestaw wszystkich instrukcji musi byæ zawarty
pomiêdzy par¹ nawiasów klamrowych . Formalnie funkcja main() nie jest czêoci¹ C ani C++, jednak traktowana jest jako integralna
czêoæ orodowiska. W ogólnym wypadku C++ dopuszcza mo¿liwooæ u¿ycia parametrów
formalnych w wywo³aniu funkcji main(), w których mog¹ byæ zapisywane
wartooci ich argumentów, tak jak pokazuje to rysunek 2.2. Jednak ten sposób
zapisu g³ównej funkcji nie bêdzie nas interesowa³, równie¿ z tego powodu, ¿e
nigdy ju¿ do niego nie powrócimy w trakcie tej ksi¹¿ki. Natomiast w wiêkszooci spotykanych przypadków mo¿na post¹piæ w sposób du¿o prostszy,
zapisuj¹c main() w taki sposób, jak pokazano y
to na
wydruku 2.1. Je¿eli funkcja main() jest okreolonego typu (w naszym przypadku typu ca³kowitego int), to powinna zwróciæ wartooæ tego samego
typu. Tutaj wykonaliomy t operacjê
poprzez instrukcjê return 0, który to zapis
jest niczym innym jak wartooci¹ powrotn¹ udostêpnian¹ w nastêpstwie wywo³ania
funkcji. Je¿eli funkcja by³aby typu void (tzw. typ pusty, pusta lista
parametrów), to nie musi zwracaæ ¿adnej wartooci.
|
Instrukcja return zastosowana w funkcji main() zwraca do systemu operacyjnego kod zakoñczenia dzia³ania funkcji (programu). Wartooæ powrotna, udostêpniana w nastêpstwie wywo³ania funkcji musi byæ liczb¹ ca³kowit¹. W MS DOS oraz Windows 3x, 9x, NT, 2000 wartooci¹ t¹ jest lub, co jest równowa¿ne wartooæ FALSE. Wszystkie pozosta³e wartooci bêd¹ sygna³em wyst¹pienia b³êdu. Podobn¹ zasad¹ kierujemy siê przy korzystaniu z ró¿nych funkcji udostêpnianych przez Win32 API. Nale¿y jednak pamiêtaæ, i¿ bardzo wiele funkcji oferowanych w Win32[EK36] przez interfejs programisty[EK37] jest typu BOOL, czyli mog¹cych w wyniku wywo³ania zwróciæ albo TRUE albo FALSE. Wówczas TRUE, czyli wartooæ niezerowa, okreola prawid³owe zakoñczenie dzia³ania funkcji. Podobn¹ zasadê
stosuj¹ niekiedy programioci przy okreolaniu wartooci powrotnej funkcji,
nie bêd¹cej czêoci¹ orodowiska programistycznego lub systemu operacyjnego,
czyli funkcji pisanej |
|
Nale¿y pamiêtaæ, ¿e zarówno C, C++, jak i C++Builder na ogó³ rozró¿niaj¹ wielkooæ liter. Pewnym wyj¹tkiem s¹ dane typu TRUE i FALSE. Tworz¹c aplikacje konsolowe przy pomocy C lub C++ nale¿y je zapisywaæ ma³ymi literami, czyli true false. W C++Builderze jest to bez znaczenia. |
Pisz¹c w C lub C++ ka¿dy program mo¿na zbudowaæ pos³uguj¹c siê jedynie prostymi instrukcjami oferowanymi przez te kompilatory. Nale¿y jednak pamiêtaæ, ¿e zarówno C jak i C++ nie posiadaj¹ wbudowanych instrukcji pozwalaj¹cych na realizacjê operacji wejocia / wyjocia, czyli opcji umo¿liwiaj¹cych wprowadzanie i wyprowadzanie na ekran, dysk lub inne urz¹dzenie komunikatów u¿ytkownika. Powoduje to koniecznooæ wywo³ywania w odpowiednim miejscu programu ró¿nych funkcji realizuj¹cych wymienione operacje wejocia / wyjocia. Wiêkszooæ takich funkcji znajduje siê w plikach nag³ówkowych C:
stdio.h (ang. standard library) zawiera j¹cej
deklaracje typów i makrodefinicje wykorzystywane przez standardowe funkcje
wejocia /wyjocia.
conio.h (ang. console input output)
zawiera j¹cej
deklaracje funkcji umo¿liwiaj¹cych komunikacjê z konsol¹. W przypadku programu
przedstawionego na wydruku 2.1 funkcja getch() reaguj¹ca ej
na nacioniêcie klawisza, np. Enter - wymaga u¿ycia conio.h.
Wszystko to jest równie¿ aktualne w C++, niemniej jednak jêzyk ten mo¿e wykorzystywaæ s³owo cout oraz operator << (w omawianym kontekocie znak graficzny << nazywamy operatorem wyjocia lub wyprowadzania danych) pozwalaj¹ce wyprowadziæ (równie¿ na ekran) ³añcuchy znaków oraz wartooci, akceptowanych przez C++ typów danych. Sekwencja dowolnej liczby znaków ujêtych w cudzys³ów nazywana jest ci¹giem znaków, tekstem lub sta³¹ tekstow¹. Instrukcja endl powoduje przesuniêcie kursora do pocz¹tku nastêpnego wiersza. W tym wypadku wymagane jest u¿ycie pliku nag³ówkowego iostream.h. Bardzo czêsto operator cout wystêpuje w parze z operatorem cin, ten ostatni s³u¿y do wczytywania i zapamiêtywania danych.
Zgodnie ze standardem ANSI ka¿da funkcja biblioteczna musi byæ zadeklarowana w pewnym zbiorze nag³ówkowym, którego zawartooæ w³¹czamy do programu przy pomocy dyrektywy #include oraz pisz¹c w ostrych nawiasach nazwê zbioru z rozszerzeniem .h. Mówimy, ¿e tego typu pliki nag³ówkowe podlegaj¹ prekompilacji. Nale¿y zwróciæ uwagê, ¿e najnowszy standard C++ z regu³y ju¿ nie wymaga stosowania tego rozszerzenia i z powodzeniem mo¿emy napisaæ np.:
#include <conio>
umo¿liwiaj¹c tym samym wykorzystywanie w naszych programach pewnych funkcji zdefiniowanych w pliku nag³ówkowym conio.h.
Przy pomocy dyrektywy #pragma jesteomy w stanie przekazaæ kompilatorowi pewne dodatkowe informacje. Je¿eli po zakoñczeniu listy plików nag³ówkowych u¿yjemy #pragma hdrstop (ang. header stop), poinformujemy kompilator, ¿e w³aonie wyst¹pi³ koniec listy plików nag³ówkowych, które maj¹ byæ prekompilowane[EK38]
U¿ycie jej tej
dyrektywy zapobiega ewentualnemu wyowietlaniu komunikatu bêd¹cego
ostrze¿eniem, ¿e jeden z argumentów funkcji nie jest wykorzystywany. Dyrektywê #pragma argsused (ang. arguments used) nale¿y umieszczaæ przed funkcj¹, tak
jak pokazuje to rys. 2.2. W naszym programie przedstawionym na wydruku 2.1
zrezygnowaliomy z tej dyrektywy niej z
oczywistych wzglêdów.
Biblioteki w³aociwe zarówno C
jak C++ s¹ opisane w ich definicjach które zawieraj¹c
jednoczeonie wszystkie niezbêdne funkcje wykorzystywane przy konstrukcji odpowiednich
programów. W momencie, kiedy zostanie u¿yta jakao funkcja nie bêd¹ca czêoci¹
programu (funkcje takie nazywamy bibliotecznymi) kompilator
zapamiêta jej nazwê. Kod wynikowy tekstu programu zostanie w odpowiedni sposób
po³¹czony z kodami istniej¹cymi w u¿ywanych bibliotekach. Proces tan okreolamy
jako konsolidacjê lub linkowanie.
Zanim zaczniemy na serio
uruchamiaæ nasze programy i aplikacje poowiêæmy
trochê uwagi niektórym kilku najwa¿niejszym
opcjom, z jakimi przy pomocy których mo¿emy
skonfigurowaæ nasz projekt. Zajrzyjmy do menu Project|Options...|Packages. Pierwsz¹, która siê pojawi bêdzie pokazana na rysunku 2.3 zak³adka Compiler
Rys. 2.3. Zak³adka Compiler |
|
Wcioniêty przycisk Full debug zapewni nam mo¿liwooæ debuggowania programu w trakcie jego pisania lub sprawdzania. Stosowanie tej konfiguracji jest zalecane na etapie projektowania i testowania programów. Je¿eli natomiast dojdziemy do wniosku, ¿e aplikacja nasza jest ju¿ w pe³ni gotowa i nie bêdzie wymaga³a dalszych ulepszeñ (nie bêdziemy ju¿ wiêcej zagl¹daæ do jej kodu), wystarczy wcisn¹æ Release. W³¹czona opcja Cache pre - compiled headers przyopieszy w³¹czanie do programu plików nag³ówkowych, które musz¹ byæ poddane prekompilacji.[EK39]
Pos³uguj¹c siê
opcjami dostêpnymi w Advanced Compiler mo¿emy m. in.
m.in.
ustaliæ typ procesora, na którym nasz program ma dzia³aæ, rozmiaru
danych oraz czy program bêdzie kompilowany w standardach zie
opisanych m przez
Borlanda, ANSI, System UNIX V lub Kernighana i Ritchie'go (K&R). Je¿eli nie
mamy jakio specjalnych wymagañ warto lepiej zbytnio
nie ingerowaæ w te opcje.
Bardzo ciekaw¹
pozycj¹ jest Runtime packages.
Je¿eli pole Build with runtime package pozostanie a zaznaczone
(bêdzie aktywne) mo¿emy mieæ spore problemy z
uruchomieniem naszego programu, o ile nie bêdzie znajdowa³ siê w instalacyjnym
katalogu Buildera \BIN. Wynika
to z faktu, ¿e nasza aplikacja do prawid³owego dzia³ania potrzebowaæ bêdzie
paru dodatkowych bibliotek. W momencie, kiedy Build with
runtime packages pozostanie odznaczone (nieaktywne)
biblioteki te zostan¹ automatycznie do³¹czone do pliku wykonywalnego programu
zwiêkszaj¹c tym samym jego rozmiar .
Dla naszych potrzeb pole to pozostanie nieaktywne, tak jak pokazano na rysunku
2.4. Kiedy do³¹czaæ lub nie poszczególne biblioteki ka¿dy musi
zadecydowaæ sam. Je¿eli zale¿y nam na otrzymaniu pliku wykonywalnego o
stosunkowo niewielkich rozmiarach mo¿emy je w³¹czyæ, nale¿y jednak pamiêtaæ,
¿e wówczas w aktualnym katalogu razem z
plikiem wykonawczym[EK40] musz¹ znajdowaæ siê poszczególne biblioteki.
Rys. 2.4. Zak³adka Packages |
|
PrzejdYmy z kolei
do zak³adki Linker. Jej wygl¹d
pokazany jest na rys. 2.5. W panelu Linking znajduje siê bardzo ciekawa opcja Use dynamic
RTL. W przypadku, gdy pozostanie ona zaznaczona,
nasz program
wykonywalny [EK41]mo¿e potrzebowaæ do prawid³owego dzia³ania dwóch niewielkich DLL-i:
zestawów
procedur DLL: borlndmm.dll oraz cc3250mt.dll.
Wymienione DLL-e zestawy procedur DLL (ang.
Dynamic Link Library) nale¿¹ do grupy bibliotek RTL (ang. Run- Time Libraries Wykorzystywane s¹
podczas uruchamiania programów wykonawczych[EK42], ponadto te z przyrostkiem mt (ang. Multi Thread)
wspomagaj¹ elementy wielow¹tkowego dzia³ania aplikacji i systemu operacyjnego.
Dla naszych potrzeb opcja ta [EK43]zostanie odznaczona[EK44], tzn. bêdziemy jawnie w³¹czaæ je[EK45] do naszych programów.
Nale¿y jednak powiedzieæ, ¿e jawne w³¹czanie do aplikacji zbyt wielu ró¿nych bibliotek nigdy nie jest dobrym pomys³em. Programy wykonywalne nie powinny byæ zbyt du¿e, by³o to jedn¹ z idei powstania bibliotek do³¹czanych dynamicznie. Czytelnik sam mo¿e siê przekonaæ, ¿e plik uruchomieniowy[EK46] bcb.exe tak potê¿nego narzêdzia, jakim jest C++Builder 5 ma rozmiar mniejszy ni¿ 1 MB.
Rys. 2.5. Zak³adka Linker z odznaczon¹ opcj¹ Use dynamic RTL |
|
Korzystaj¹c z karty Application mo¿emy nadaæ w³asny, unikalny tytu³ projektowanej aplikacji, jak równie¿ zmieniæ jej ikonê, któr¹ np. mo¿emy wykonaæ sami pos³uguj¹c siê przedstawionym na rys. 1.34 edytorem graficznym.
Przy pomocy Version Info mo¿emy kontrolowaæ wersjê programu. Kompilator bêdzie automatycznie podawaæ kolejny numer wersji po ka¿dej kompilacji, pod warunkiem oczywiocie, ¿e zaznaczymy opcjê Auto-increment build number. Ciekawostk¹ jest równie¿ mo¿liwooæ umieszczenia tu danych o autorze programu, jak i krótkiego opisu programu.
Teraz, kiedy dokonaliomy w³aociwych ustawieñ opcji projektu mo¿emy skompilowaæ i uruchomiæ projekt naszego modu³u Unit01.cpp zawieraj¹cego tekst Yród³owy programu. Wystarczy w tym celu u¿yæ opcji menu Run|Run F9) lub proociej, z paska narzêdzi wybierzmy przycisk Run F9). Po uruchomieniu na ekranie powinniomy zobaczyæ okienko DOS, w którym wyowietlany jest napis bêd¹cy efektem wykonania programu:
Rys. 2.6. Projekt01.exe w trakcie dzia³ania |
|
Efekt dzia³ania programu na pewno nie jest czymo bardzo odkrywczym, niemniej jednak stanowiæ bêdzie dla nas pretekst do zapoznania siê z pewnymi wa¿nymi pojêciami, których zrozumienie oka¿e siê niezbêdne, je¿eli zechcemy w przysz³ooci projektowaæ naprawdê dobrze dzia³aj¹ce aplikacje.
Zajrzyjmy do katalogu \Projekt01, powinno znajdowaæ siê w nim 6 plików:
Projekt01.exe. Jest programem wykonywalnym (ang. executable program). Powsta³ on w wyniku dzia³ania konsolidatora ³¹cz¹cego standardowe funkcje biblioteki C++ z naszym kodem Unit01.cpp. Je¿eli odpowiednio skonfigurowaliomy opcje projektu (tak jak na rysunkach 2.4 oraz 2.5) program ten mo¿na uruchamiaæ samodzielnie bez koniecznooci odwo³ywania siê do innych plików.
Projekt01.bpr. Zawiera wszystkie niezbêdne instrukcje wykorzystywane przy tworzeniu
projektu (ang. builder project)[2].
S¹
nimi Jest tam opis
samego projektu, opis opcji ustawieñ orodowiska programisty IDE[EK47], opcji ustawieñ konsolidatora i wiele innych opisów.
Zawartooci tego pliku w ¿adnym wypadku nie nale¿y rêcznie
modyfikowaæ rêcznie, ani nazwy jego
zmieniaæ jego nazwy w sposób dowolny, tzn.
korzystamy jedynie z menu File|Save Project
As... Pliki takie s¹ przechowywane w formacie XML.
Po uruchomieniu Buildera, kiedy chcemy poddaæ edycji nasz program, otwieramy go
odwo³uj¹c siê do nazwy jego projektu poleceniem File|Open
Project
Projekt01.bpf. Projekt pliku (ang. borland project file) utworzony w
przypadku, gdy K korzystamy ze
orodowiska C++Buildera, zao programy piszemy w C lub C++, tak jak w naszym
przyk³adzie.
Projekt01.tds. (ang. table debug symbols). Plik binarny przechowuj¹cy
informacje m. in. m.in.o
w³¹czonych bibliotekach i plikach nag³ówkowych. Jest tworzony w momencie
konsolidacji programu.
Unit01.cpp. Jest tekstem Yród³owym programu (ang. source code). Tekst Yród³owy, który czêsto bywa nazywany kodem, jest bezpoorednio wczytywany przez kompilator.
Unit01.obj. Jest kodem wynikowym programu (ang. object code). Stanowi translacjê (przek³ad) tekstu Yród³owego na jêzyk zrozumia³y dla komputera. Kod wynikowy jest zawsze wczytywany przez konsolidator (linker).
Wszystkie wymienione pliki powinny znajdowaæ siê w katalogu, w którym zapisujemy projekt aplikacji. Utworzenie oddzielnego katalogu dla ka¿dego z projektów bardzo u³atwia pracê z C++Builderem, w sposób znacz¹cy ogranicza te¿ mo¿liwooæ przypadkowej utraty któregoo ze zbiorów. Nale¿y zdawaæ sobie sprawê z faktu, ¿e je¿eli utracimy np. plik projektu .bpr, aplikacjê bêdziemy musieli projektowaæ praktycznie od pocz¹tku.
Po przeczytaniu tego rozdzia³u powinniomy siê nieco oswoiæ ze orodowiskiem programisty [EK48]oferowanym przez Borland C++Builder 5. Wiemy ju¿ co to jest projekt, z jakich elementów siê sk³ada i jaka jest ich struktura. Umiemy te¿ odpowiednio, wed³ug w³asnych potrzeb skonfigurowaæ opcje projektu. Wiadomooci te oka¿¹ siê nam bardzo pomocne w dalszej czêoci ksi¹¿ki. Pokazaliomy te¿, ¿e korzystaj¹c ze orodowiska BCB 5 [EK49]mo¿emy pisaæ konsolowe programy w "tradycyjnym" C++, a nawet w zwyk³ym C. Pewne dodatkowe elementy jêzyka C++ zostan¹ przedstawione w nastêpnym rozdziale.
W rozdziale tym krótko omówimy podstawowe typy danych, z jakimi mo¿emy spotkaæ siê pisz¹c programy w jêzyku C++. Trochê miejsca poowiêcimy instrukcjom steruj¹cym, przypomnimy te¿ sposób budowy i wykorzystania funkcji oraz struktur. Przypomnimy pojêcie wskaYnika i adresu.
Zarówno w jêzyku C jak i w jêzyku C++ wyró¿niamy piêæ podstawowych typów danych:
int typ ca³kowity. U¿ywany jest do zapamiêtywania i zapisywania liczb ca³kowitych.
float typ zmiennopozycyjny (zmiennoprzecinkowy)
double typ zmiennoprzecinkowy podwójnej d³ugooci. Zmienne typu float oraz double umo¿liwiaj¹ zapamiêtywanie i zapisywanie liczb rzeczywistych, posiadaj¹cych czêoæ ca³kowit¹ i u³amkow¹. Czêoæ u³amkow¹ oddzielamy kropk¹.
char typ znakowy. Typ ten stosujemy do zapamiêtywania i zapisywania znaków ASCII oraz krótkich liczb reprezentowanych na 8 bitach.
void
typ pusty. Wykorzystywany bywa w nastêpuj¹cych sytuacjach. Po pierwsze, korzystaj¹c
z niego za jego pomoc¹ mo¿emy deklarowaæ
funkcje nie zwracaj¹ce ¿adnych wartooci. Po drugie, mo¿emy deklarowaæ deklaruj¹c
funkcje które nie
pobieraj¹ ce argumentów.
Po trzecie, umo¿liwia on tworzenie ogólnych wskaYników.
|
Ka¿da zmienna u¿yta w programie musi byæ najpierw zadeklarowana, to znaczy nale¿y poinformowaæ kompilator z jakiego typu danymi przyjdzie mu pracowaæ. W³aonie na tej podstawie dokonuje siê sprawdzania poprawnooci rezultatu wykonania danej operacji arytmetycznej lub logicznej. Zmienne globalne mo¿na deklarowaæ b¹dY przed wywo³aniem g³ównej funkcji main(), b¹dY w jej ciele[EK50] |
Jako przyk³ad wykorzystania
w programie jednego z opisanych wy¿ej tych typów
danych niech nam pos³u¿y prosty algorytm przedstawiony na wydruku 3.1.
Wydruk 3.1. Algorytm realizuj¹cy operacjê dodawania dwóch liczb typu float
#include <iostream.h>
#include <conio.h>
#pragma hdrstop
float x, y, z; // deklaracja zmiennych
int main()
W tym prostym przyk³adzie wykorzystaliomy operatory dodawania oraz instrukcjê przypisania
Spooród innych operatorów arytmetycznych nale¿y wyró¿niæ:
Operator Dzia³anie Postaæ matematyczna
odejmowanie z = x - y;
mno¿enie z = x * y;
dzielenie z = x / y;
dzielenie modulo z = x % y;
zmniejszanie o jeden (dekrementacja) z = z - 1;
zwiêkszanie o jeden (inkrementacja) z = z + 1;
skrót przypisania z += x; to samo co: z = z + x;
skrót odejmowania z = x; z = z - x;
skrót mno¿enia z *= x; z = z * x;
skrót dzielenia z /= x; z = z / x;
|
Ogólna postaæ instrukcji przypisania wygl¹da nastêpuj¹co: Zmienna wyra¿enie; Mo¿na te¿ stosowaæ wielokrotnie takie instrukcje, np.: z = x = y = 0; |
Jedyn¹ i najlepsz¹ metod¹ zapoznania siê z w³aociwoociami zmiennych oraz ze sposobami u¿ycia niektórych operatorów arytmetycznych jest wykonanie paru æwiczeñ.
Æwiczenie 3.1.
Po
uruchomieniu C++Buildera W wybierz File|New|Console Wizard. Opcjê Console Wizard S skonfiguruj
podobnie jak na rys. 2.1
1. Pos³uguj¹c siê kodem pokazanym na wydruku 3.1, S spróbuj
przetestowaæ dzia³anie programu.
2. Zmodyfikuj program w ten sposób, by przetestowaæ dzia³anie omówionych operatorów arytmetycznych.
3. Oblicz wartooæ wyra¿enia (x
+ y)*y /(y - x). Podobnie jak na wydruku 3.1 W wyowietl
w postaci komunikatu, jakie dzia³ania by³y kolejno wykonywane.
4. SprawdY rezultat dzia³ania programu z ró¿nym wykorzystaniem operatorów dekrementacji oraz inkrementacji, np.:
cout << x << " + " << y << " = " << z++;
oraz
cout << x << " + " << y << " = " << ++z;
Ka¿da ró¿na od zera
liczba, z któr¹ spotykamy siê w C, posiada wartooæ TRUE (prawda) , natomiast liczba 0 - posiada
wartooæ FALSE (nieprawda). Wyra¿enia, w
których wystêpuj¹ operatory relacyjne b¹dY logiczne, zwracaj¹
wartooæ 1 (TRUE) lub 0, czyli FALSE. W zale¿nooci od potrzeb pos³ugujemy siê nastêpuj¹cymi
operatorami:
Operatory relacyjne
Operator Dzia³anie
> W wiêkszy
< M mniejszy
> W wiêkszy
lub równy
< M mniejszy
b¹dY równy
R równy
R ró¿ny
Operatory logiczne
Operator Dzia³anie
&& K koniunkcja
AND (i)
A alternatywa
OR (lub)
N negacja
NOT (nie)
Pos³uguj¹c siê przedstawionymi operatorami nale¿y zawsze pamiêtaæ, ¿e posiadaj¹ one ró¿ny priorytet wykonywania kolejnych dzia³añ. Rozpatrzmy to na przyk³adzie wyra¿enia . Jego wartooæ obliczana jest w taki sposób, ¿e najpierw zostanie wykonana operacja odejmowania liczb, a dopiero potem sprawdzony warunek, czy rezultat odejmowania jest ró¿ny od zera, tzn.: . Nale¿y te¿ pamiêtaæ, ¿e operator ma najwiêkszy priorytet. Je¿eli nie jesteomy pewni priorytetów stosowanych operatorów zawsze w w¹tpliwych sytuacjach mo¿emy pos³u¿yæ siê w³aonie operatorem
Tablice s³u¿¹ do
zapamiêtywania danych tego samego typu
i, Ppodobnie
jak zmienne wymagaj¹ przed u¿yciem deklaracji.
Deklaruj¹c tablicê informujemy nasz komputer o potrzebie przydzielenia
odpowiedniej ilooci pamiêci oraz o kolejnooci rozmieszczenia elementów tablicy.
W najprostszy sposób tablicê zawieraj¹c¹ 10 liczb ca³kowitych deklarujemy
nastêpuj¹co:
int Tablica[10];
Dla komputera oznaczaæ to bêdzie potrzebê zarezerwowania 10 kolejnych pól pamiêci dla 10 liczb ca³kowitych typu int. Ka¿da taka liczba bêdzie zapamiêtana na 4 bajtach. Deklaruj¹c tablice, np. Tablica[n] nale¿y pamiêtaæ, ¿e w C++ poszczególne ich elementy s¹ ponumerowane za pomoc¹ indeksu od do n-1. W naszym przypadku kolejnymi elementami tablicy bêd¹: Tablica[0] Tablica[1] Tablica[9]. W bardzo prosty sposób przypisujemy wartooci elementom tablic, np.:
Tablica[5] = 25;
W analogiczny sposób deklarujemy tablice znakowe. Je¿eli zapiszemy:
char znak[20];
Oznaczaæ to bêdzie, ¿e zarezerwowaliomy w pamiêci 20 8-bitowych pól, w których bêd¹ przechowywane dane typu char. Do takiej tablicy równie¿ mo¿emy wpisaæ ³añcuch znaków:
char napis[20] = "Borland C++Builder 5";
lub, co jest równowa¿ne:
char napis[11] = ;
Mimo, i¿ napis "Borland C++Builder 5" sk³ada siê z 20 znaków (spacje te¿ s¹ traktowane jako znaki), to musieliomy zadeklarowaæ tablicê sk³adaj¹c¹ siê równie¿ z 20 elementów, a nie 19 (pamiêtamy, ¿e indeksy liczymy od 0). Wynika to z faktu, ¿e C++ pos³uguje siê ³añcuchami znakowymi zakoñczonymi znakiem '\0' NUL (ASCII 00). Je¿eli taki napis zechcemy wyowietliæ wystarczy napisaæ:
cout << endl << napis;
Tablice mog¹ byæ
jednowymiarowe (tzw. wektory) lub wielowymiarowe. Je¿eli zeachcemy
zadeklarowaæ dwuwymiarow¹ tablicê sk³adaj¹c¹ siê z 10 elementów typu float, mo¿emy napisaæ:
float Tablica [2][5];
Co o Oznaczaæ
to bêdzie
nastêpuj¹ce ponumerowanie jej indeksów:
Tablica[0][0], Tablica[0][1], Tablica[0][2], Tablica[0][3], Tablica[0][4]
Tablica[1][0], Tablica[1][1], Tablica[2][2], Tablica[2][3], Tablica[2][4]
Elementom takich tablic równie¿ mo¿na przypisywaæ wartooci. Na przyk³ad:
float Tablica[2][3] = , };
Co o Oznaczaæ
to bêdzie
przypisanie jej indeksom nastêpuj¹cych wartooci:
Tablica[0][0]=1; Tablica[0][1]=2; Tablica[0][2]=3;
Tablica[1][0]=4; Tablica[1][1]=5; Tablica[1][2]=6.5;
Elementy takich tablic wyowietlamy w sposób bardzo prosty:
cout << endl << Tablica[1][1];
W C oraz C++ zdefiniowane s¹ trzy kategorie instrukcji steruj¹cych:
Instrukcje warunkowe, niekiedy nazywane instrukcjami wyboru, czyli if oraz switch
Instrukcje iterakcyjne, zwane te¿ instrukcjami pêtli, lub po prostu pêtlami. Nale¿¹ do nich for while oraz do...while
Instrukcje skoku: break continue goto
|
Instrukcja return jest te¿ zaliczana do instrukcji skoku, z tego powodu, i¿ wykonanie jej wp³ywa na przebieg wykonywania funkcji lub programu jako ca³ooci. |
W ogólnym przypadku blok instrukcji if przyjmuje nastêpuj¹c¹ postaæ:
if (wyra¿enie)
else
Zastosowanie jej
rozpatrzmy na przyk³adzie prostego programu wykonuj¹cego operacjê dzielenia.
Operacje takie w pewnych wypadkach mog¹ byæ trochê niebezpieczne dla naszego
algorytmu, gdy¿ jak zapewne wiemy jest niedopuszczalne jest wykonywanie
dzielenia przez zero.
Wydruk. 3.2. Program obrazuj¹cy ideê pos³ugiwania siê blokiem instrukcji if
#include <iostream.h>
#include <conio.h>
#pragma hdrstop
void main()
else
cout << endl << "Uwaga! Próba dzielenia przez zero";
cout << x << " + " << y <<" = " << z;
cout << endl << "Nacionij klawisz...";
getch();
Æwiczenie 3.2.
Wykorzystuj¹c
jako oci¹gawkê kod programu przedstawionego na wydruku 3.2, S sprawdY rezultat jego wykonania z innymi
operatorami relacji.[EK51]
Decyzyjna instrukcja switch (niekiedy nazywana instrukcj¹ przesiewu) porównuje kolejno wartooci wyra¿enia, które musi byæ typu ca³kowitego, znakowego lub wyliczeniowego z list¹ liczb ca³kowitych, lub innych sta³ych znakowych.
switch( wyra¿enie typu ca³kowitego int, znakowego char lub enum )
Jako przyk³ad praktycznego wykorzystania omawianej instrukcji niech nam pos³u¿y poni¿szy algorytm.
Wydruk. 3.3. Sposób u¿ycia w programie instrukcji decyzyjnej switch.
#include <iostream.h>
#include <conio.h>
#pragma hdrstop
int x = 3, y, z;
int main()
cout << endl << "Nacionij klawisz...";
getch();
return false;
Po uruchomieniu
programu wpisujemy jak¹o liczbê, która bêdzie przechowywana w zmiennej y. Nastêpnie zostanie wykonana operacja odejmowania wprowadzonej liczby
od liczby zadeklarowanej w programie i przechowywanej w zmiennej x. Wynik dzia³ania zostanie przypisany zmiennej z. Nastêpnie nast¹pi wystêpuje cykl
sprawdzaj¹cy, jak¹ liczb a jest rezultat
odejmowania. Instrukcja default bêdzie wykonana w tedy wtedy,
gdy nie bêdzie mo¿na znaleYæ wartooci zgodnej z wartooci¹ wyra¿enia podanego w switch
Æwiczenie 3.3.
Postaraj siê zaprojektowaæ algorytm rozró¿niaj¹cy wprowadzane z klawiatury znaki. Jako przyk³ad niech nam pos³u¿y poni¿szy szkielet programu:
char znak;
int main()
Ka¿de wspó³czesne orodowisko programistyczne [EK52]udostêpnia nam mo¿liwooæ wykonywania ci¹gu instrukcji a¿ do spe³nienia za³o¿onego warunku. W instrukcji for warunek taki okreolany jest mianem warunku predefiniowanego.
W ogólnej postaci instrukcja for sk³ada siê z trzech g³ównych czêoci:
for(inicjalizacja; predefiniowany warunek; inkrementacja)
Instrukcje tego typu pos³uguj¹ siê z regu³y tzw. zmiennymi steruj¹cymi (licznikiem wykonañ). W czêoci inicjalizuj¹cej zmiennej steruj¹cej zostanie nadana wartooæ pocz¹tkowa[EK53]. Ca³ooæ instrukcji bêdzie wykonywana do czasu spe³nienia predefiniowanego warunku. Sposób modyfikacji zmiennej steruj¹cej po ka¿dorazowym zakoñczeniu danego cyklu [EK54]jest zdefiniowany w czêoci inkrementacyjnej. [EK55]
|
Instrukcja for nie mo¿e byæ zakoñczona
orednikiem. Znak okreola koniec wykonywanych
instrukcji. Ka¿da instrukcja for zakoñczona orednikiem |
Sposób
wykorzystania w programie wymienionej instrukcji pomorz e
nam zilustrowaæ przyk³ad programu cyklicznie wyowietlaj¹cego kwadraty oraz
pierwiastki kwadratowe liczb ca³kowitych z przedzia³u <1; 10>.
Wydruk 3.4. Idea pos³ugiwania siê instrukcj¹ for.
#include <iostream.h>
#include <conio.h>
#pragma hdrstop
double i, j, k;
int main()
cout << endl << "Nacionij klawisz...";
getch();
return 0;
W celu obliczenia pierwiastka liczby u¿yliomy funkcji sqrt(), której rezultat musi byæ liczb¹ zmiennoprzecinkow¹, np. double. Do obliczania kwadratu liczby wykorzystana zosta³a funkcja pow(), której ogólna definicja brzmi:
double pow(double x, double y);
Matematyczny zapis tej funkcji jest bardzo prosty: xy
Oczywiocie funkcjê tê z powodzeniem mo¿na u¿yæ równie¿ do obliczania pierwiastka kwadratowego: pow(x, 0.5), co oznacza x lub jakichkolwiek innych potêg.
Æwiczenie 3.4.
W pêtli for [EK56]O oblicz i W wyowietl
sumê oraz ró¿nicê trzecich potêg czterech ró¿nych liczb ca³kowitych. Zakres
zmiennooci tych liczb ustalmy od 1 do 20.
Ciekaw¹ w³asnooci¹
jêzyka C, która zosta³a oczywiocie zaadoptowana¹ równie¿
do jêzyka
C++ jest mo¿liwooæ wykorzystania w
programie pêtli nieskoñczonej w postaci for(;;), tzn. nie
sprawdza siê tutaj ¿adnych warunków kontynuacji. Aby zakoñczyæ wykonywanie
takiej pêtli, nale¿y w odpowiednim miejscu
programu u¿yæ instrukcji break. Poni¿szy przyk³ad ilustruje to
zagadnienie.
Wydruk.3.5. Nieskoñczona pêtla for.
#include <iostream.h>
#include <conio.h>
#pragma hdrstop
double i = 1, j;
int main()
cout << endl << "Nacionij klawisz...";
getch();
return 0;
Instrukcja iterakcyjna while przybiera nastêpuj¹c¹ postaæ:
while(warunek)
Powy¿sza pêtla bêdzie wykonywana tak d³ugo, dopóki warunek nie bêdzie spe³niony, przy czym jego prawdziwooæ sprawdzana jest przed wykonaniem grupy instrukcji. Kiedy warunek przybierze wartooæ FALSE, dzia³anie programu bêdzie kontynuowane od pierwszej instrukcji znajduj¹cej siê za pêtl¹. Poni¿szy przyk³ad pomo¿e nam zrozumieæ mechanizm dzia³ania pêtli while
Wydruk. 3.6. Kwadraty liczb ca³kowitych obliczane w pêtli while.
#include <iostream.h>
#include <conio.h>
#pragma hdrstop
double i = 1, j;
int main()
cout << endl << "Nacionij klawisz...";
getch();
return 0;
Æwiczenie 3.5.
Zmodyfikuj pokazany na powy¿szym wydruku program w ten sposób, by cyklicznie wyowietla³ wprowadzane z klawiatury znaki, a¿ do momentu wybrania litery 'a'. W tym celu mo¿na pos³u¿yæ siê funkcj¹ getchar()
Istnieje zasadnicza ró¿nica pomiêdzy instrukcjami for while oraz do...while. O ile w przypadku for oraz while warunek wykonywania instrukcji sprawdzany jest ju¿ na pocz¹tku, to w przypadku do...while sprawdza siê go na koñcu. Z faktu tego wynika, ¿e instrukcje znajduj¹ce siê w pêtli do...while bêd¹ wykonane co najmniej jeden raz. Pêtla ta w ogólnej postaci wygl¹da nastêpuj¹co:
dowhile(warunek);
Zamieszczony poni¿ej przyk³ad programu, wczytuj¹cego dowolne znaki wprowadzane z klawiatury pomo¿e nam zrozumieæ zasadê dzia³ania pêtli do...while, która bêdzie wykonywana do momentu wprowadzenia ma³ej lub du¿ej litery 'x'
Wydruk 3.7. Zasada dzia³ania instrukcji powtarzaj¹cej do...while.
#include <iostream.h>
#include <conio.h>
#pragma hdrstop
char znak;
int main()
while (znak != 'x' && znak != 'X');
cout << endl << "Nacionij klawisz...";
getch();
return 0;
Æwiczenie 3.6.
Korzystaj¹c z powy¿szego przyk³adu, Zbuduj algorytm obliczaj¹cy i wyowietlaj¹cy na ekranie pierwiastki trzeciego stopnia ca³kowitych liczb nieujemnych z przedzia³u od 20 do 50.
Jednym z
najwa¿niejszych elementów zarówno jêzyka C jak i jêzyka C++
s¹ funkcje. Wiemy ju¿, ¿e ka¿dy pisany przez nas program musi zawieraæ
przynajmniej jedn¹ funkcjê
funkcjê main(). W miêdzyczasie p Poznaliomy
te¿ ju¿ parê funkcji bibliotecznych oferowanych w standardzie ANSI C
bBy³y
nimi: getch() getchar() getche() pow() czy chocia¿by sqrt(). W celu odró¿nienia funkcji od
zmiennych po nazwie funkcji piszemy nawiasy
okr¹g³e. Funkcje s¹ najprostszym sposobem ujêcia pewnych obliczeñ, dzia³añ czy
innych operacji w jednym elemencie strukturalnym, do którego mo¿emy odwo³ywaæ
siê wielokrotnie w trakcie programu.
Z anatomicznego punktu
widzenia Z punktu widzenia budowy funkcji, ka¿da
funkcja
z
nich sk³ada siê z nastêpuj¹cych elementów:
Rys. 3.1. Budowa funkcji w C++ |
|
Najlepsz¹ metod¹
zapoznania siê ze sposobami u¿ycia funkcji w programie jest stworzenie
odpowiedniego algorytmu. Pamiêtamy, ¿e dotychczas w celu obliczenia potêgi
jakiejo liczby wykorzystywaliomy biblioteczn¹ funkcjê pow(). Zbudujmy teraz samodzielnie jej prosty odpowiednik.
n Nasza
funkcja, nazwijmy j¹ power (potêga) bêdzie
oblicza³a wartooci kolejnych ca³kowitych potêg liczby 2.
Wydruk 3.8. Program korzystaj¹cy z funkcji power() w celu obliczania kolejnych potêg liczby 2.
#include <iostream.h>
#include <conio.h>
#pragma hdrstop
int power(int x, int y); // prototyp funkcji
int i;
int main()
int power(int x, int y) // definicja funkcji power (potêga)
Ka¿da funkcja,
samodzielnie przez nas napisana przed u¿yciem musi byæ odpowiednio
zadeklarowana w programie. Deklarujemy j¹ przed g³ówn¹ funkcj¹ main(). Dzia³anie to okreola siê mianem podania prototypu funkcji wraz z jej
parametrami formalnymi. Parametry formalne s¹ takimi parametrami, z jakimi
funkcja jest zadeklarowana. W naszym przyk³adzie parametrami takimi s¹ dane
typu int x oraz y. Nastêpnie treoæ naszej funkcji umieszczamy za g³ównym programem. Samo
wywo³anie funkcji power(), ju¿ z parametrami aktualnymi,
nastêpuje w treoci g³ównej funkcji main(). Parametrami aktualnymi,
nazywamy dane, z jakimi funkcjê wywo³ujemy.
|
Istniej¹ dwa sposoby do³¹czenia w³asnej funkcji do programu. Je¿eli treoæ funkcji zdecydujemy siê umieociæ za g³ównym programem, nale¿y podaæ jej prototyp. Je¿eli treoæ funkcji umieszczamy bezpoorednio przed g³ówn¹ funkcj¹ main() podawanie prototypu nie jest wymagane. |
Wielk¹ zalet¹ pos³ugiwania siê funkcjami jest to, ¿e mo¿emy do nich odwo³ywaæ siê wielokrotnie z mo¿liwooci¹ podawania za ka¿dym razem innych parametrów aktualnych, np.:
cout << endl << power(2,i) << " " << power (3,i) << " " << power(4,i);
W ogólnooci w W jêzykach
C oraz C++ wywo³ywana funkcja na ogó³ nie zmienia wartooci zmiennych
w funkcjach wywo³uj¹cych. Mówimy, ¿e tego rodzaju funkcje przekazuj¹ swe
argumenty przez wartooæ. Je¿eli zachodzi potrzeba, by funkcja zmienia³a
wartooci zmiennych w funkcji wywo³uj¹cej, to ta ostatnia musi przekazaæ adres
zmiennej, zao funkcja wywo³ywana musi zadeklarowaæ odpowiedni argument jako
wskaYnik.
Æwiczenie 3.7.
Zaprojektuj program, który bêdzie pe³niæ rolê najprostszego
kalkulatora. Wszystkie podstawowe dzia³ania, takie jak: dodawanie, odejmowanie,
mno¿enie, dzielenie czy obliczanie odwrotnooci liczb U umieoæ
w odpowiednich funkcjach. Funkcje te nale¿y wywo³ywaæ w g³ównym programie z
odpowiednimi parametrami aktualnymi.
Zarówno w jêzyku C jak i C++ istniej¹ dwa bardzo wa¿ne pojêcia, którymi czêsto pos³ugujemy siê pisz¹c programy. S¹ nimi wskazanie i adres. Wskazaniem nazywamy dane identyfikuj¹ce pewien obiekt, którym mo¿e byæ np. zmienna lub funkcja. Adresem nazywamy pewien atrybut danej wskazuj¹cej lokalizuj¹cy jej miejsce w pamiêci. [EK57]W ogólnym wypadku powiemy, ¿e wskaYnik jest zmienn¹, która zawiera adres innej zmiennej w pamiêci komputera. Istniej¹ dwa bardzo wa¿ne operatory umo¿liwiaj¹ce nam pos³ugiwanie siê adresami obiektów.
Jednoargumentowy operator & (zwany operatorem adresowym lub referencji) podaje adres obiektu. Je¿eli zapiszemy:
px = &x;
oznaczaæ to bêdzie, ¿e wskaYnikowi px przypisaliomy adres zmiennej x. Powiemy, ¿e px wskazuje na zmienn¹ x, lub ¿e px jest wskaYnikiem do zmiennej x
Z kolei operator (gwiazdka) zwany operatorem wy³uskiwania w dzia³aniu na zmienn¹ [EK58]spowoduje, ¿e zmienna taka bêdzie traktowana jako adres danego obiektu. Operator ten traktuje swój argument jako adres obiektu i u¿ywa tego adresu do pobrania zawartooci obiektu.
Rozpatrzmy dwie grupy instrukcji wykonuj¹cych podobnie wygl¹daj¹ce przypisania:
y = x;
oraz
px = &x;
y = *px;
O pierwszym przypisaniu
z nich powiemy, ¿e wykonuj¹c je
nadajemy zmiennej y dotychczasow¹ wartooæ zmiennej x. O drugim zao powiemy, ¿e najpierw wskaYnikowi px przypisaliomy adres zmiennej x, a nastêpnie zmiennej y nadaliomy dotychczasow¹ wartooæ zmiennej, której adres wskazuje wskaYnik
px. Widzimy wiêc, ¿e te dwie grupy instrukcji wykonuj¹ dok³adnie to samo.
Zrozumienie idei u¿ycia w programie wskazañ i adresów u³atwi nam poni¿szy
wydruk.
Wydruk 3.9. Program
obliczaj¹cy kolejne potêgi liczby 2. Wywo³uj¹c funkcjê power() korzystamy ze wskaYnika do danej[EK59] i, bêd¹c¹ kolejn¹ która jest potêg¹
liczby 2 a zarazem parametrem aktualnym
funkcji.
#include <iostream.h>
#include <conio.h>
#pragma hdrstop
int power(int x, int *y); // prototyp funkcji
int i;
int main()
int power(int x, int *y) // zapis funkcji power (potêga)
Funkcja power(int x, int *y) bêdzie zmieniaæ wartooæ jednego ze swoich argumentów ca³kowitych. Je¿eli zechcemy, by w momencie wywo³ania przekazywaæ argumenty przez adres, zmienna (lub zmienne) przekazywana funkcji power() musi byæ poprzedzona operatorem & power(2, &i) tylko wówczas bêdzie utworzony odpowiedni wskaYnik.
Strukturê tworzy zbiór zmiennych, z³o¿ony z jednej lub z logicznie powi¹zanych kilku zmiennych ró¿nych typów zgrupowanych pod jedn¹ nazw¹. Najprostszym przyk³adem wykorzystania struktur mog¹ byæ wszelkiego rodzaju listy p³ac pracowników czy chocia¿by dane zwi¹zane z ewidencj¹ ludnooci. Struktury stosujemy po to, by u³atwiæ sobie zorganizowanie pracy z wiêksz¹ ilooci¹ skomplikowanych danych. Podobnie jak ka¿dy typ danych, równie¿ i struktura wymaga deklaracji w programie. Istnieje kilka sposobów deklaracji struktury. Na potrzeby naszej ksi¹¿ki przedstawimy jeden z najprostszych. Aby logicznie pogrupowaæ dane ró¿nych typów stosujemy struktury deklarowane przy pomocy s³owa kluczowego struct. Nastêpnie podajemy nazwê struktury okreolaj¹c w ten sposób jej typ. W nawiasach klamrowych deklarujemy elementy sk³adowe struktury (czêsto zwane polami). Na koniec nale¿y z regu³y podaæ listê nazw struktur okreolonego typu, z których bêdziemy w przysz³ooci korzystaæ.
Jako przyk³ad zadeklarujmy
strukturê typu y Student, w której elementach bêdziemy przechowywaæ pewne dane zwi¹zane z
osobami wybranych studentów.
struct Student // deklaracja ogólnego typu struktury Student
Tak wiêc w kolejnych polach przechowywaæ bêdziemy imiê i nazwisko danej osoby, oceny z egzaminów wybranych przedmiotów i na koniec nasz¹ opiniê o studencie.
Nastêpnie zainicjujmy dwie struktury statyczne typu Student pod nazwami Student1 oraz Student2
static struct Student
Student1 = ;
static struct Student
Student2 = ;
|
Je¿eli zechcemy, aby struktura zajmowa³a stale ten sam obszar pamiêci oraz aby by³a dostêpna z ka¿dego miejsca programu nale¿y zadeklarowaæ j¹ jako statyczn¹ static |
Oczywiocie w ten sam sposób mo¿emy utworzyæ jeszcze szereg innych struktur danego typu, co zilustrowane jest na przyk³adzie algorytmu pokazanego na wydruku 3.9.
Wydruk 3.10. Przyk³ad wykorzystania informacji zawartych w strukturach
#include <iostream.h>
#include <conio.h>
#pragma hdrstop
int main()
struct Student // deklaracja ogólnego typu struktury Student
static struct Student
Student1 = ;
static struct Student
Student2 = ;
struct Student S3, S4;
S3 = Student2;
S3.EgzaminFizyka = Student1.EgzaminFizyka;
S4 = Student1;
cout << endl << S3.Imie <<" "<< S3.Nazwisko <<" "<<
S3.EgzaminFizyka<<" "<< S3.EgzaminMatematyka<<" "<<
S3.EgzaminInformatyka;
cout << endl << S4.JakiStudent;
cout << endl << "Nacionij klawisz...";
getch();
return 0;
Analizuj¹c powy¿szy wydruk na pewno zauwa¿ymy, ¿e aby przekazaæ wartooæ pojedynczego pola numerycznego struktury Student1 do struktury S3 wykonaliomy przypisanie:
S3.EgzaminFizyka = Student1.EgzaminFizyka;
St¹d wniosek, ¿e po to, by odwo³aæ siê do danego elementu struktury nale¿y podaæ jej nazwê i po kropce wybrany element (pole) struktury. Je¿eli zechcemy przekazaæ zawartooæ ca³ej struktury do innej tego samego typu wykonujemy normalne przypisanie podaj¹c ich nazwy:
S3 = Student2;
Widzimy wiêc, ¿e struktury pomagaj¹ zorganizowaæ sobie pracê z danymi ró¿nych typów. Wówczas grupa zwi¹zanych ze sob¹ zmiennych mo¿e byæ traktowana jako jeden obiekt. Zagadnienie struktur w C++ jest niezwykle bogate. Z racji charakteru ksi¹¿ki pominiête zosta³y takie pojêcia, jak tablice struktur, wskaYniki do struktur czy opis struktur odwo³uj¹cych siê do samych siebie. Pojêcia takie wprowadza siê na zaawansowanym kursie programowania, zatem zainteresowanych Czytelników odsy³am do bogatej literatury przedmiotu. Z powodzeniem mo¿na te¿ skorzystaæ z niezwykle bogatych w te treoci plików pomocy C++Buildera 5.
Æwiczenie 3.8.
Zaprojektuj program, przy pomocy którego B bêdziesz
móg³ przechowywaæ wszystkie interesuj¹ce informacje o swoich znajomych (adres,
nr telefonu, e-mail, itp.).
W niniejszym rozdziale zosta³y przedstawione podstawowe pojêcia zwi¹zane z programowaniem w C++. Omówiliomy podstawowe typy danych, operatory arytmetyczne i logiczne, tablice, instrukcje steruj¹ce przebiegiem dzia³ania programu, funkcje oraz struktury. Przypomnienie wiadomooci na temat wskazañ i adresów bardzo nam w przysz³ooci pomo¿e w zrozumieniu mechanizmu obs³ugi zdarzeñ ju¿ z poziomu Borland C++Builder 5. Przedstawienie szeregu po¿ytecznych przyk³adów praktycznego wykorzystania elementów jêzyka C++ u³atwi nam samodzielne wykonanie zamieszczonych w tym rozdziale æwiczeñ.
Projektowanie obiektowe (ang. object-oriented design) stanowi zespó³ metod i sposobów pozwalaj¹cych elementom sk³adowym aplikacji staæ siê odpowiednikiem obiektu lub klasy obiektów rzeczywiocie istniej¹cych w otaczaj¹cym nas owiecie. Wszystkie aplikacje budujemy po to, by odzwierciedla³y lub modelowa³y rzeczywistooæ, która nas otacza. Aplikacje takie bêd¹ zbiorem wspó³dzia³aj¹cych ze sob¹ ró¿nych elementów. Przed rozpoczêciem tworzenia takiego programu nale¿y zastanowiæ siê, jakie cele ma on spe³niaæ i przy pomocy jakich elementów (obiektów) cele te bêd¹ realizowane. Nale¿y zatem:
Zdefiniowaæ nowy (lub zaimplementowaæ istniej¹cy) typ danych - klasê.
Zdefiniowaæ obiekty oraz ich atrybuty.
Zaprojektowaæ operacje, jakie ka¿dy z obiektów ma wykonywaæ.
Ustaliæ zasady widocznooci obiektów.
Ustaliæ zasady wspó³dzia³ania obiektów.
Zaimplementowaæ ka¿dy z obiektów na potrzeby dzia³ania aplikacji.
Ustaliæ mechanizm dziedziczenia obiektów.
Definiuje nowy typ danych, bêd¹cych w istocie po³¹czeniem danych i instrukcji, które wykonuj¹ na nich [EK60]dzia³ania umo¿liwiaj¹c tworzenie (lub wykorzystanie istniej¹cych) obiektów bêd¹cych reprezentantami klasy. Jedna klasa mo¿e byæ Yród³em definicji innych klas pochodnych.
Stanowi element rzeczywistooci, któr¹ charakteryzuje pewien stan. Ka¿demu obiektowi zawsze mo¿na przypisaæ okreolony zbiór metod, czyli operacji. Klasa jest równie¿ obiektem.
Ka¿dy wykorzystywany w programie obiekt wykonuje (lub my wykonujemy na nim) pewne czynnooci - operacje, potocznie zwane metodami. Metodami nazywamy funkcje (lub procedury) bêd¹ce elementami klasy i obs³uguj¹ce obiekt przynale¿ny do danej klasy.
Je¿eli uznamy to za konieczne, mo¿emy ustaliæ zakres widocznooci obiektów w odniesieniu do fragmentu programu. Obiekt taki bêdzie korzysta³ ze zmiennych dostêpnych jedynie dla metod klasy, w której je zdefiniowano.
Je¿eli obiekt lub grupê obiektów uczynimy widocznymi w ca³ej aplikacji, nale¿y ustaliæ zasady porozumiewania siê obiektów, czyli relacje pomiêdzy nimi. Dla ka¿dego z obiektów ustalamy ociole okreolony zbiór regu³ i funkcji, dziêki którym korzystaæ z niego mog¹ inne obiekty.
Implementacja, czyli oprogramowanie obiektu oznacza stworzenie kodu Yród³owego obs³uguj¹cego metody z nim zwi¹zane. W szczególnooci korzystaj¹c z zasad programowania obiektowo zdarzeniowego, z poszczególnymi obiektami kojarzymy odpowiadaj¹ce im zdarzenia.
Zdarzenie (ang. event) okreolane jest jako zmiana wystêpuj¹ca w aktualnym stanie obiektu, bêd¹ca Yród³em odpowiednich komunikatów przekazywanych do aplikacji lub bezpoorednio do systemu. Reakcja obiektu na wyst¹pienie zdarzenia udostêpniana jest aplikacji poprzez funkcjê obs³ugi zdarzeñ (ang. event function) bêd¹c¹ wydzielon¹ czêoci¹ kodu.
Jest mechanizmem programowania obiektowego. Pozwala na przekazywanie w³aociwooci klas bazowych klasom pochodnym (potomnym). Nowe klasy bêd¹ dziedziczyæ, czyli przejmowaæ z klas, bêd¹cych ich przodkami pola, metody, instrukcje i w³aociwooci.
Zapoznamy siê teraz z jednym ze sposobów b³yskawicznego zaprojektowania i stworzenia aplikacji w orodowisku C++ Builder 5 pos³uguj¹c siê technik¹ programowania zorientowanego obiektowo. W tym celu zbudujemy naprawdê prosty program, którego zadaniem bêdzie wyowietlenie w odpowiednim miejscu formularza znanego nam ju¿ napisu. Wykorzystuj¹c polecenie menu File|New|Application stwórzmy na pulpicie nowy formularz.
Korzystaj¹c z karty w³aociwooci inspektora obiektów w jego cechê Caption (opis) wpiszmy Projekt02. Cechê Name (nazwa) pozostawmy nie zmienion¹ jako Form1 . Poleceniem File|Save As... zapiszmy g³ówny modu³ projektu w katalogu \Projekt02\Unit02.cpp.
Nastêpnie poprzez File|Save Project As... w tym samym katalogu zapiszmy sam projekt jako Projekt02.bpr. W ten prosty sposób przygotowaliomy nasz formularz do dalszych dzia³añ.
Formularz jest pierwszym obiektem, z którym spotykamy siê rozpoczynaj¹c pisanie aplikacji. Je¿eli modu³ tworzonego obecnie projektu zapisaliomy jako \Projekt02\Unit02.cpp, to w tym samym katalogu C++Builder powinien wygenerowaæ plik nag³ówkowy Unit02.h. Zerknijmy do jego wnêtrza. Zostawmy na boku dyrektywy preprocesora, natomiast przypatrzmy siê dok³adnie definicji tworz¹cej klasê naszego formularza:
Wydruk 4.1. Zawartooæ modu³u Unit02.h.
#ifndef 02H
#define 02H
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
class TForm1 : public TForm
extern PACKAGE TForm1 *Form1;
#endif
W³aonie
otrzymaliomy automatycznie wygenerowan¹ przez BCB (skrót od Borland C++
Builder) definicjê przyk³adowej klasy, na bazie której bêd¹ w przysz³ooci
tworzone obiekty. BCB oferuje nam s³owo kluczowe class pozwalaj¹ce na
tworzenie obiektów. Przed stworzeniem obiektu okreolamy jego ogóln¹ postaæ
korzystaj¹c w³aonie ze s³owa class. Klasa TForm1 dziedziczy w³asnooci klasy TForm, bêd¹cej bazow¹ klas¹ a
formularza. Definicja klasy sk³ada siê z kilku czêoci. W sekcji __published umieszczane bêd¹
deklaracje funkcji, czyli deklaracje
metod zwi¹zanych z komponentami pochodz¹cymi z biblioteki VCL. [EK61]Sekcja private przeznaczona jest dla zmiennych (zwanych tutaj polami) oraz metod
widzianych tylko wewn¹trz klasy. W sekcji public deklarowaæ
mo¿na pola i metody mog¹ce byæ udostêpniane innym.
|
Zauwa¿my, ¿e C++Builder umo¿liwia te¿ tworzenie aplikacji nie zawieraj¹cych formularza (por. Projekt01.exe, który by³ aplikacj¹ konsolow¹), zatem klasa TForm1 nie mia³a tam zastosowania. Z faktu tego wynika brak pliku Unit01.h w wymienionym projekcie. |
Zanim
zaczniemy na serio korzystaæ z obiektu naszego formularza musi on zostaæ
odpowiednio zainicjowany. Dokonuje siê to tego
poprzez specjaln¹ funkcjê sk³adow¹, nosz¹c¹ tak¹ sam¹ nazwê jak klasa, do której
nale¿y[EK62]. Prototyp takiej funkcji (nazywanej konstruktorem
z parametrami wygl¹da nastêpuj¹co:
__fastcall TForm1(TComponent* Owner);
Poniewa¿
konstruktor nie zwraca ¿adnej wartooci, nie okreola
siê jego typu (przez domniemanie jest on typu nieokreolonego, czyli void). Konwencja __fastcall (szybkie wywo³anie)
zapewnia, ¿e parametry konstruktora zostan¹ przekazane poprzez rejestry
procesora. Dodatkowo
zapis konstruktora z parametrem Owner informuje, ¿e w³aocicielem (ang. owner) wszystkich
komponentów jest TComponent mówi nam, ¿e TComponent jest wspólnym przodkiem dla
wszystkich komponentów z biblioteki VCL w³¹cznie ze stworzon¹ klas¹ TForm1 [EK63]Klasa Tcomponent, wprowadzaj¹c wiele metod i w³aociwooci, umo¿liwia m. in.
m.in.
obs³ugê komponentów z poziomu inspektora obiektów. Pe³ny tekst
konstruktora klasy TForm1 zostanie automatycznie umieszczony
w module Unit02.cpp, tam te¿ zostanie on zainicjowany.
Jak siê zapewne domyolamy
projekt naszej aplikacji bêdzie sk³ada³ siê nie tylko z formularza
ale równie¿ z modu³ów i innych zasobów. Wszystkie czêoci sk³adowe aplikacji
przechowywane s¹ w odpowiednich plikach w wiêkszooci
wypadków tworzonych automatycznie przez BCB. Poniewa¿ C++Builder 5 (podobnie
jak C i C++) pozwala na konsolidacjê oddzielnie skompilowanych modu³ów du¿ego
programu, musi zatem istnieæ jakio sposób na poinformowanie wszystkich plików
wchodz¹cych w sk³ad projektu o wystêpowaniu zmiennych globalnych (widocznych w
ca³ej aplikacji) niezbêdnych w danym programie.
Najlepszym sposobem by to osi¹gn¹æ, jest zadeklarowanie zmiennych globalnych
tylko w jednym pliku i wprowadzenie deklaracji u¿ywaj¹c przy pomocy specyfikatora extern PACKAGE (ang. zewnêtrzny
pakiet) w innych plikach (zob. wydruk 4.1).
Nasz formularz jest obiektem lub jak kto woli zmienn¹ obiektow¹, której deklaracja zostanie umieszczona w g³ównym module formularza Unit02.cpp:
#include <vcl.h>
#pragma hdrstop
#include "Unit02.h"
TForm1 *Form1;
Widzimy wiêc, ¿e nazwa klasy sta³a siê nowym specyfikatorem typu danych.
Po tych byæ mo¿e
trochê d³ugich, ale moim zdaniem bardzo wa¿nych
wyjaonieniach zobaczmy jak w praktyce pos³ugiwaæ ujemy
siê klas¹ TForm1 i w jaki sposób mo¿emy uzupe³niæ j¹ o szereg obiektów.
Pisz¹c programy w orodowisku BCB z regu³y korzystamy z biblioteki VCL. Chocia¿ do jej omawiania przejdziemy dopiero w nastêpnych rozdzia³ach, nic nie stoi na przeszkodzie, abyomy ju¿ teraz powoli zaczêli oswajaæ siê z jej elementami. Jest to równie¿ dobry moment by zapoznaæ siê z jeszcze paroma w³aociwoociami inspektora obiektów.
Æwiczenie 4.1.
1. Ustalmy na pocz¹tek rozmiary formularza. Cechê Height (wysokooæ) ustalmy, powiedzmy na 300 pikseli, zao cechê Width (szerokooæ) na 480.
2. Rozwiñmy cechê Constraints (ograniczenie). W odpowiednie miejsca wpiszmy wartooci pokazane na rys. 4.1.
Rys. 4.1. Ograniczenie rozmiarów formularza |
|
Przypisuj¹c
poszczególnym cechom wartooci zgodne z uprzednio ustalonymi rozmiarami
formularza, uzyskamy taki efekt, taki
¿e w momencie uruchomienia aplikacji formularz nie bêdzie "rozp³ywa³" siê po
ekranie w nawet po klikniêciu na pole
maksymalizacji.
3. PrzejdYmy do cechy Position i wybierzmy np. poScreenCenter (rys. 4.2).
Rys. 4.2. Cecha Position inspektora obiektów |
|
Spooród
widocznych opcji (które mo¿emy samodzielnie przetestowaæ), wybrana przez
nas sprawi
zapewni, ¿e w momencie uruchomienia
aplikacji jej formularz pozostanie w centrum
ekranu (ale nie pulpitu). Je¿eli oczywiocie w inspektorze obiektów nie
ustawiliomy inaczej jak na alNone cechy
Align (zakotwiczenie). nie
ustawiliomy inaczej, ni¿ na alNone[EK64]
4. Na koniec, nale¿y zadbaæ o postaæ kursora, jaki bêdzie obowi¹zywaæ w obszarze formularza. Standardowym kursorem jest crDefault (domyolny). Je¿eli pojawia nam siê jakio inny kursor ( i je¿eli nam nie odpowiada) w obszarze formularza, rozwiñmy cechê Cursor inspektora obiektów i wybierzmy kursor domyolny (rys. 4.3). Oczywiocie, w zale¿nooci od upodobañ ka¿dy mo¿e wybraæ ten najbardziej mu odpowiadaj¹cy.
Rys. 4.3. Rodzaje dostêpnych kursorów |
|
Skoro posiadamy ju¿ pewne
wiadomooci na temat obiektowej natury formularza oraz ustaliliomy wstêpnie jego
parametry, to na tak przygotowanej formie mo¿emy ju¿ umieociæ odpowiednie
komponenty. Poniewa¿ jedynym zadaniem naszego programu bêdzie wyowietlenie w
odpowiedni sposób napisu analogicznego jak na rys. 2.6 pos³u¿ymy siê
dwoma komponentami TButton z karty Standard. Aby je przenieoæ do obszaru
formy nale¿y klikn¹æ na komponent z podpowiedzi¹ Button, a nastêpnie równie¿ klikaj¹c, ale ju¿ w obszarze
formularza umieociæ go w odpowiednim miejscu. Forma
naszego projektu powinna wygl¹daæ tak jak na rys. 4.4.
Rys.
4.4. Sposób rozmieszczenia komponentów TButton na |
|
Korzystaj¹c z
inspektora obiektów oraz z karty w³aociwooci -
Properties, cechê Caption przycisku Button2 zmieñ na &Zamknij. Podobnie cechê Caption przycisku Button1 zmieñ na &Tekst. Cechy Name pozostawimy nie zmienione jako Button1 oraz Button2 Oczywiocie, ¿eby zmieniæ cechy tych
przycisków, nale¿y najpierw je zaznaczyæ, tylko
raz klikaj¹c na odpowiedni komponent. Znak &, który wystêpuje w nazwach przycisków oznacza, ¿e litera,
stoj¹ca bezpoorednio po nim bêdzie stanowiæ klawisz szybkiego
dostêpu (szybkiego wywo³ania) do funkcji obs³ugi odpowiedniego zdarzenia.
Równie¿ przy pomocy inspektora obiektów mo¿emy zmieniæ ich
cechy Font obu
przycisków[EK65] dobieraj¹c
najbardziej
odpowiadaj¹cy nam rodzaj czcionki. tym samym rodzaj najbardziej
odpowiadaj¹cej nam czcionki.
Przyciski umieszczone na
formularzu wygl¹daj¹ na pewno bardzo ³adnie, niemniej jednak musz¹ jeszcze
spe³niaæ okreolon¹ rolê w naszej aplikacji, mianowicie nale¿y uczyniæ je
zdolnymi do generowania zdarzeñ. Dla ka¿dego z nich nale¿y stworzyæ funkcjê
obs³ugi zdarzenia. Zacznijmy od przycisku zamykaj¹cego aplikacjê. Klikaj¹c
dwukrotnie na przycisk Zamknij,
dostaniemy siê do wnêtrza odpowiedniej funkcji obs³ugi zdarzenia Button2Click()
void __fastcall TForm1::Button2Click(TObject *Sender)
Jednak zanim cokolwiek tam wpiszemy, przeanalizujmy pokrótce powy¿sze zapisy. Ju¿ teraz zagl¹daj¹c do pliku Unit02.h zobaczymy, ¿e w deklaracji klasy TForm1 wystêpuje prototyp funkcji (metody) Button2Click() która od tej pory [EK66]sta³a siê funkcj¹ sk³adow¹ klasy. W miejscu, w którym wystêpuje pe³en tekst Yród³owy funkcji sk³adowej klasy (w naszym wypadku w pliku g³ównego modu³u formularza Unit02.cpp), kompilator musi byæ poinformowany, do której klasy wywo³ywana funkcja nale¿y. Dokonujemy tego pos³uguj¹c siê operatorem
|
U¿ycie operatora
rozró¿nienia zakresu (ang. scope resolution operator) informuje kompilator, ¿e przyk³adowa
funkcja Button2Click() nale¿y do przyk³adowej klasy TForm1. Poniewa¿
klasy C++Buildera mog¹ zawieraæ wiele funkcji (metod) o takich samych nazwach,
nale¿y poinformowaæ kompilator o tym, ¿e w danej chwili którao z nich mo¿e
byæ wykorzystywana |
Do w miarê pe³nego opisu konstrukcji funkcji obs³ugi przyk³adowego zdarzenia potrzeba jeszcze wyjaoniæ rolê jej parametrów. Z zapisu:
TObject *Sender
odczytamy: *Sender jest wskaYnikiem i wskazuje na dane typu TObject Sender reprezentuje tutaj pewn¹ w³aociwooæ polegaj¹c¹ na tym, ¿e ka¿dy obiekt z listy palety komponentów VCL musi byæ w pewien sposób poinformowany o tym, ¿e bêdzie przypisana mu funkcja obs³ugi zdarzenia.
|
TObject jest bezwzglêdnym przodkiem wszystkich komponentów i obiektów VCL. Umieszczony jest na samym szczycie hierarchii obiektów VCL. W C++Builder 5 wszystkie egzemplarze obiektów maj¹ postaæ 32-bitowych wskaYników do przydzielonej na stosie pamiêci. |
Poni¿ej przedstawiona funkcja obs³ugi zdarzenia zapewnia, ¿e po uruchomieniu, aplikacja w stosownym dla nas momencie mo¿e byæ bezpiecznie zamkniêta w odpowiedzi na wywo³anie tej funkcji, czyli nacioniêcie odpowiedniego przycisku:
void __fastcall TForm1::Button2Click(TObject *Sender)
Ka¿dy program BCB zawiera zmienn¹ globaln¹ Application typu TApplication, która deklarowana jest nastêpuj¹co:
__fastcall virtual TApplication(Classes::TComponent* AOwner);
extern PACKAGE TApplication* Application;
W czasie tworzenia nowego projektu C++Builder konstruuje obiekt aplikacji i przypisuje mu w³aonie zmienn¹ Application. Obiekty klasy TApplication przechowuj¹ zasady wspó³pracy aplikacji z systemem operacyjnym Windows, takie jak rozpoczynanie i koñczenie aplikacji, tworzenie okna g³ównego itp. W³aociwooci i zdarzenia wymienionej klasy nie s¹ dostêpne z poziomu inspektora obiektów, natomiast w³aociwooci aplikacji mo¿emy zmieniaæ za pomoc¹ opcji menu Project|Options...|Forms lub Application
Istnieje wiele metod klasy TApplication, jedn¹ z nich: Terminate(), któr¹ w³aonie przeæwiczyliomy. Jej pe³na deklaracja wygl¹da nastêpuj¹co:
void __fastcall Terminate(void);
Funkcja ta umo¿liwia zamkniêcie aplikacji. Terminate() nie jest oczywiocie jedyn¹ z prostszych w u¿yciu metod, które oferuje TApplication. Nastêpn¹, równie prost¹ i u¿yteczn¹ jest funkcja:
void __fastcall Minimize(void);
któr¹ ka¿dy mo¿e wypróbowaæ ju¿ samodzielnie.
Nale¿y oczywiocie pamiêtaæ, ¿e do olbrzymiej wiêkszooci metod przynale¿nych do odpowiednich klas odwo³ujemy siê poprzez operator ->
|
Operatory (kropka) i -> (strza³ka) wykorzystywane s¹ do uzyskiwania dostêpu do pojedynczych elementów zbiorczych typów danych, np. struktur i unii, do których jako ca³ooci odwo³ujemy siê poprzez podanie ich nazwy. Kropkê wykorzystujemy w przypadku wykonywania dzia³añ na tych obiektach, strza³kê zao podczas korzystania ze wskaYników do tych typów danych. Pod wzglêdem sk³adni (zob. wydruk 4.1) klasa przypomina strukturê, ale ró¿ni siê od niej tym, ¿e oprócz obiektów mo¿e zawieraæ te¿ funkcje, tzn. wi¹¿e strukturê danych i mo¿liwe do wykonania operacje na tej strukturze danych. |
PrzejdYmy
teraz do zaprojektowania funkcji obs³ugi zdarzenia dla przycisku Button1, który nazwaliomy Tekst. Aby wyowietliæ odpowiedni napis na formularzu, zastosujemy
najprostsz¹ metodê, mianowicie wykorzystamy fakt, ze ka¿dy formularz
bêd¹cy w istocie pewnym komponentem posiada swoje
w³asne p³ótno (ang. canvas ), reprezentowane przez klasê TCanvas posiadaj¹c¹ w³aociwooæ Canvas . P³ótno stanowi obszar, na w
którym mo¿emy wykonywaæ bardzo wiele operacji graficznych. Funkcja obs³ugi
zdarzenia Button1Click() skojarzona z przyciskiem Button1 mo¿e wygl¹daæ jak poni¿ej:
void __fastcall TForm1::Button1Click(TObject *Sender)
Widzimy, ¿e sposób odwo³ywania siê do obszaru p³ótna poprzez w³aociwooæ Canvas klasy TCanvas nie jest skomplikowany i nie powinien przedstawiaæ nam ¿adnych trudnooci. Wykorzystaliomy tutaj kilka w³aociwooci p³ótna, takich jak: czcionka (Font) i pêdzel (Brush) oraz metodê TextOut() klasy TCanvas. Wykorzystuj¹c zagnie¿d¿enie obiektów odwo³aliomy siê tak¿e do ich poszczególnych w³asnooci, takich jak: kolor (Color), styl (Style) oraz wysokooæ (Height Funkcja:
void __fastcall TextOut(int X, int Y, const AnsiString Text);
pPozwala
na umieszczenie dowolnego tekstu identyfikowanego przez sta³¹ Text w miejscu formularza o wspó³rzêdnych X Y.(o Odleg³ooæ
liczona jest w pikselach. Lewy górny róg formularza ma wspó³rzêdne 0, 0 Nasza aplikacja po uruchomieniu powinna
wygl¹daæ podobnie jak na rys. 4.5.
Rys. 4.5. Projekt02.bpr po uruchomieniu |
|
Skoro tak dobrze nam idzie, to wypróbujmy jeszcze jeden komponent z karty Standard, mianowicie komponent edycyjny typu TEdit, który jak ju¿ powinniomy siê domyolaæ bêdzie reprezentowany w³aonie przez okienko o nazwie Edit1. Po wstawieniu go do formularza ustalmy jego rozmiar oraz typ czcionki (w³aociwooæ Font w inspektorze obiektów). Wykonajmy ponadto jeszcze dwie bardzo ciekawe czynnooci. Mianowicie cechy DragKind (rodzaj przemieszczania) oraz DragMode (tryb przemieszczania) ustalmy tak, jak pokazuje to rysunek 4.6.
Rys. 4.6. W³aociwooci DragKind oraz DragMode inspektora obiektów |
|
Ponadto, funkcjê obs³ugi zdarzenia Button2Click() uzupe³nijmy o niewielki fragment kodu:
//-- umieszczamy tekst w oknie edycji Edit1 --
Edit1->Font->Color = clRed;
Edit1->Text = "Pierwsza aplikacja w C++Builder 5";
Widzimy,
¿e oprócz znanych ju¿ nam w³aociwooci Font i Color u¿yliomy
jeszcze jednej - Text. Takie przypisanie ci¹gu znaków ujêtych w cudzys³owy spowoduje, ¿e
tekst ten zostanie wyowietlony w oknie
edycji, do
którego cechy Text jest przypisany[EK67]. Uruchommy aplikacjê i od razu kliknijmy w obszar edycji
Edit1 potem zao na przycisk Tekst. Wygl¹d formularza dzia³aj¹cej aplikacji pokazany jest na rys. 4.7.
Rys. 4.7. Zmodyfikowany Projekt02.bpr po uruchomieniu |
|
Dziêki odpowiednim ustawieniom, dokonanym przy pomocy inspektora obiektów w odniesieniu do komponentu Edit1, mamy mo¿liwooæ swobodnego przesuwania go po ca³ym ekranie, a tak¿e dowolnego zmieniania jego rozmiarów. Ju¿ na takich prostych przyk³adach mo¿emy poznaæ potêgê programowania zorientowanego obiektowo. Kilka ruchów myszk¹ przy sprowadzaniu komponentów w odpowiednie miejsce formularza, parê linijek kodu i trochê pracy z inspektorem obiektów a efekt jest naprawdê dobry.
Na pewno te¿ zauwa¿ymy, ¿e przesuwaj¹c okienko po ekranie,
w pewnym momencie zaczniemy zamazywaæ tekst wyowietlany na p³ótnie formularza.
Nasze okno dzia³a jak gumka do ocierania. Có¿, trzeba siê z tym liczyæ
nawet sama nazwa Canvas (p³ótno) sugeruje, ¿e wszystko
co umieszczamy na formularzu korzystaj¹c z w
w³aociwooci i metod p³ótna nie bêdzie zbyt trwa³e. W³aonie z
tego powodu komponenty edycyjne odgrywaj¹ tak du¿¹ rolê w bibliotece VCL.
Poni¿ej zamieszczony zosta³ kompletny kod g³ównego modu³u naszej aplikacji.
Wydruk
4.2 Kod g³ównego modu³uy Unit02.cpp
projektu Projekt02.bpr
#include <vcl.h>
#pragma hdrstop
#include "Unit02.h"
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
void __fastcall TForm1::Button1Click(TObject *Sender)
void __fastcall TForm1::Button2Click(TObject *Sender)
Przedstawiony powy¿ej bardzo prosty algorytm ma jednak pewn¹ wadê, mianowicie je¿eli raz zamkniemy Edit1 (dziêki jego w³asnemu polu zamkniêcia), to ju¿ nie bêdziemy mieli mo¿liwooci by w trakcie dzia³ania aplikacji odzyskaæ je[EK68] z powrotem. Mo¿emy zapobiec takiej sytuacji, projektuj¹c chocia¿by funkcje obs³ugi dwóch nowych zdarzeñ, uruchamianych powiedzmy poprzez dwa nowe przyciski typu TButton z wykorzystaniem metod Hide() (ukryj) i Show() (poka¿):
//------ukrywa okno edycji Edit1-------- ----- ------ -----
void __fastcall TForm1::Button3Click(TObject *Sender)
//-------przywraca okno edycji Edit1-------- ----- ------ -
void __fastcall TForm1::Button4Click(TObject *Sender)
Powy¿sze zapisy powinny nam wyjaoniæ jeszcze jedn¹ bardzo wa¿n¹ rzecz, mianowicie w jaki sposób nale¿y odwo³ywaæ siê do obiektów oraz ich w³aociwooci i metod w funkcjach obs³ugi zdarzeñ zwi¹zanych z zupe³nie innymi obiektami.
Na zakoñczenie tego fragmentu naszych rozwa¿añ zauwa¿my, ¿e funkcje obs³ugi zdarzeñ budowane w oparciu o komponenty biblioteki VCL nie zwracaj¹ wartooci powrotnej poprzez instrukcjê return
Jak ju¿ wczeoniej wspominaliomy wszystkie sk³adniki naszej aplikacji przechowywane s¹ w plikach. Zagl¹daj¹c do katalogu \Projekt02 przyjrzyjmy siê z jakiego rodzaju plikami mamy do czynienia:
Znany nam ju¿ wykonywalny plik wynikowy Projekt02.exe. Jest utworzonym przez nas programem.
Plik g³ówny projektu Projekt02.bpr. O jego roli w naszej aplikacji ju¿ wczeoniej wspominaliomy.
Projekt02.tds table debug symbols, równie¿ powinien byæ ju¿ nam znany.
Kod wynikowy aplikacji, czyli plik Projekt02.obj.
Plik zasobów Projekt02.res. Jest binarnym plikiem zasobów (ang. resources). Zawiera m. in. ikonê.
Plik g³ówny naszej aplikacji, czyli Projekt02.cpp. Zawiera funkcjê WinMain()
Wydruk 4.3. Zawartooæ pliku z funkcj¹ WinMain().
#include <vcl.h>
#pragma hdrstop
USERES("Projekt02.res");
USEFORM("Unit02.cpp", Form1);
WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)
catch (Exception &exception)
return 0;
Programy pisane w
Borland C++Builderze i pos³uguj¹ce siê klas¹ formularza nie zawieraj¹ funkcji main().Wszystkie pisane przez nas aplikacje rozpoczynaj¹ dzia³anie od
wywo³ania innej funkcji, mianowicie WinMain(), wywo³ywanej zgodnie z zasadami WINAPI, co jest wyraYnie zaznaczone w jej definicji. Otrzymuje ona wartooæ czterech
parametrów. Pierwsze dwa, typu HINSTANCE w wolnym
t³umaczeniu okreolane jako uchwyty lub jak kto woli identyfikatory przypadku
s¹ niezbêdne z prostego powodu, mianowicie Windows w obecnym kszta³cie jest
systemem wielozadaniowym, w zwi¹zku z tym w danej chwili mo¿e dzia³aæ
jednoczeonie wiele egzemplarzy tego samego programu. Parametry przypisane typom
HINSTANCE okreolaj¹ aktualnie dzia³aj¹ce egzemplarze programu. Parametr typu LPSTR jest wskaYnikiem do ³añcucha znaków zawieraj¹cego argumenty wiersza
poleceñ, które s¹ okreolane w trakcie uruchamiania aplikacji. Ostatni parametr
typu ca³kowitego int okreola sposób wyowietlania okna
formularza po rozpoczêciu dzia³ania aplikacji. Proces inicjacji inicjalizacji
metoda Initialize(), tworzenia formularza - metoda CreateForm() oraz uruchamiania aplikacji -
metoda Run() rozgrywa siê pomiêdzy klauzulami try...catch (w
wolnym t³umaczeniu: próbuj...przechwyæ, z³ap). Je¿eli proces ten nie powiedzie
siê, na ekranie ujrzymy stosowny komunikat w postaci wygenerowanego przez
system tzw. wyj¹tku (ang. exception), wyowietlanego
przy pomocy funkcji ShowException()
Plik modu³u Unit02.cpp. Zawiera kod Yród³owy modu³u.
Unit02.h zawiera omawian¹ ju¿ definicjê klasy formularza.
Unit02.dfm jest plikiem zawieraj¹cym definicjê obiektu formularza oraz definicje obiektów wszystkich u¿ywanych komponentów.
Poniewa¿ wiemy ju¿, co to jest formularz i jak jest zorganizowany projekt, bez przeszkód mo¿emy korzystaj¹c z C++Buildera uruchomiæ program, którego kod Yród³owy zosta³ przedstawiony na wydruku 3.9. Zaprojektujmy w tym celu formularz sk³adaj¹cy siê z 6 komponentów TEdit TLabel oraz dwóch TButton. Sposób rozmieszczenia wymienionych komponentów pokazany jest na rysunku 4.8. Cechy Text komponentów TEdit wyczyoæmy, cechy Caption przycisków Button1 oraz Button2 zmieñmy odpowiednio na &Informacja o studencie oraz &Zamknij
Rys. 4.8. Sposób rozmieszczenia komponentów na formularzu aplikacji Projekt03.bpr |
|
Cechy Caption komponentów TLabel zmienimy w funkcji FormCreate(). Aby dostaæ siê do jej wnêtrza wystarczy dwa razy klikn¹æ w
obszar formularza. Wydruk 4.4 przedstawia kod modu³u Unit03.cpp
aplikacji Projekt03.bpr wykorzystuj¹cej napisan¹ przez nas
wczeoniej (wydruk 3.9) deklaracjê ogólnego typu struktury Student. Funkcja obs³ugi zdarzenia Button1Click() uruchamia zdarzenie
polegaj¹ce na wyowietleniu aktualnej informacji o danej osobie. Informacja ta
przechowywanae jest w
statycznej strukturze Student1 bêd¹cej oczywiocie typu Student
Wydruk 4.4. Kod Yród³owy modu³u Unit03.cpp aplikacji wykorzystuj¹cej definicjê struktury Student.
#include <vcl.h>
#pragma hdrstop
#include "Unit03.h"
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
struct Student // deklaracja ogólnego typu struktury Student
;
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
void __fastcall TForm1::FormCreate(TObject *Sender)
void __fastcall TForm1::Button1Click(TObject *Sender)
Edit1->Text = Student1.Imie;
Edit2->Text = Student1.Nazwisko;
Edit3->Text = Student1.EgzaminFizyka;
Edit4->Text = Student1.EgzaminMatematyka;
Edit5->Text = Student1.EgzaminInformatyka;
Edit6->Text = Student1.JakiStudent;
void __fastcall TForm1::Button2Click(TObject *Sender)
Æwiczenie 4.2.
Pos³uguj¹c siê algorytmem pokazanym na wydruku 4.4 uzupe³nij go
samodzielnie o mo¿liwooæ wyowietlenia informacji o drugim studencie. Mo¿emy to
zrobiæ w funkcji obs³ugi odrêbnego zdarzenia lub w wykorzystuj¹c
instrukcjê if(...) w tej samej funkcji.
Zapoznamy siê teraz
z jedn¹ z metod umieszczania w programie pisanym w C++Builderze w³asnej
funkcji. W tym celu wykorzystamy skonstruowan a
przez nas wczeoniej funkcjê obliczaj¹c¹ kolejne potêgi
liczby 2 (zob. wydruk 3.8). Formularz projektu naszej aplikacji, nazwijmy j¹ Projekt04.bpr
sk³adaæ siê bêdzie z dwóch przycisków Button1 oraz Button2 reprezentuj¹cych klasê TButton. Wykorzystamy te¿ komponent
edycyjny TMemo
Samodzielnie napisan¹ funkcjê
mo¿emy umieszczaæ w kodzie Yród³owym aplikacji na parê sposobów. Oto kilka
z nich. Do najczêociej stosowanych nale¿¹:
Definicjê funkcji umieszczamy w sposób najprostszy z mo¿liwych:
TForm1 *Form1;
int power(int x, int y) // definicja funkcji power
Wywo³anie funkcji
nastêpuje
¹pi w kontekocie obs³ugi danego
zdarzenia i nie ró¿ni siê niczym od jej wywo³ania stosowanego w "tradycyjnym"
C++.
Drugi sposób jest tylko trochê bardziej skomplikowany, mianowicie funkcje definiujemy korzystaj¹c z konwencji __fastcall
TForm1 *Form1;
int __fastcall power(int x, int y) // definicja funkcji power
Zastosowanie U¿ycie
tej konwencji zapewni nam spowoduje, ¿e
trzy pierwsze parametry funkcji mog¹ zostaæ przekazane przez rejestry
procesora. Mimo takiej modyfikacji wywo³anie funkcji pozostaje dalej
"tradycyjne".
Istnieje te¿ mo¿liwooæ, aby nasza funkcja sta³a siê jawnym obiektem klasy formularza TForm1. Nale¿y wówczas jej definicjê nag³ówkow¹ uzupe³niæ o nazwê klasy, do której ma przynale¿eæ wraz z operatorem rozró¿nienia zakresu:
int __fastcall TForm1::power(int x, int y)
Jednak w tym przypadku nale¿y umieociæ jej definicjê równie¿ w definicji klasy znajduj¹cej siê w pliku z rozszerzeniem .h w jednej z sekcji, np.:
class TForm1 : public TForm
W tym wypadku klasa potrzebuje zdefiniowania prototypu funkcji.
Korzystaj¹c ze
sposobu w³¹czenia w³asnej funkcji do definicji klasy zyskujemy bardzo wiele,
mianowicie wewn¹trz w ciele naszej
funkcji mo¿emy bez problemów odwo³ywaæ siê do innych obiektów formularza
wWszystkie
w³asnooci, cechy, zdarzenia i metody w³aociwe tym obiektom bêd¹ widoczne w
naszej funkcji.
Na rysunku 4.9
pokazano wygl¹d dzia³aj¹cej aplikacji obliczaj¹cej kolejne potêgi liczby 2.
Znana nam funkcja power(),
realizuj¹ca to zagadnienie, zosta³a zdefiniowana jako element
klasy formularza, przez co wewn¹trz niej w jej ciele
mo¿na umieociæ komponent, w tym wypadku Memo1, w którym
wyowietlamy odpowiednie informacje dotycz¹ce wykonywania aktualnego
potêgowania. Kompletny kod zastosowanego przeze mnie algorytmu zosta³
zamieszczony na wydruku 4.5.
|
Wydruk 4.5. Modu³ Unit04.cpp aplikacji Projekt04.bpr wykorzystuj¹cej definicjê funkcji power()
#include <vcl.h>
#pragma hdrstop
#include "Unit04.h"
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
int __fastcall TForm1::power(int x, int y) // definicja funkcji power
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
void __fastcall TForm1::FormCreate(TObject *Sender)
void __fastcall TForm1::Button1Click(TObject *Sender)
void __fastcall TForm1::Button2Click(TObject *Sender)
Æwiczenie 4.3.
Pos³uguj¹c siê algorytmem
pokazanym na wydruku 4.5 Pprzetestuj
zaprezentowane sposoby umieszczania w³asnej funkcji w aplikacji pisanej w
C++Builderze.
W ten sam sposób przetestuj dzia³anie funkcji, w której parametry deklarowane s¹ przy pomocy wskaYników.
W niniejszym rozdziale zosta³y przedstawione niezbêdne wiadomooci na temat teorii organizacji projektu (aplikacji) pisanego w orodowisku Borland C++Builder 5 wykorzystuj¹cego elementy programowania zorientowanego obiektowo. Elementy teorii organizacji projektu zosta³y uzupe³nione o konkretne przyk³adowe rozwi¹zania prowadz¹ce do zrozumienia ogólnych zasad tworzenia aplikacji. Zapoznaliomy siê równie¿ z paroma praktycznymi sposobami wykorzystania inspektora obiektów. Wyjaonione zosta³y pojêcia klasy, konstruktora klasy oraz funkcji obs³ugi zdarzenia. Samodzielnie wykonana prosta aplikacja pozwoli te¿ zrozumieæ, co to jest zdarzenie i w jaki sposób z poziomu funkcji obs³uguj¹cych wybrane zdarzenia odwo³ywaæ siê do innych obiektów aplikacji. Zosta³o te¿ pokazane w jaki sposób mo¿emy odwo³ywaæ siê do samodzielnie napisanych struktur oraz funkcji i jak uczyniæ je równoprawnymi obiektami formularza.
Na potrzeby tej ksi¹¿ki komponentami nazywaæ bêdziemy te obiekty, które mo¿emy pobraæ z palety komponentów i umieociæ je na formularzu aplikacji. Czynnooæ t przeæwiczyliomy w poprzednim rozdziale. Komponenty VLC s¹ podstawowymi elementami, z których budujemy aplikacjê. W rozdziale tym omówimy krótko podstawowe komponenty VCL oraz hierarchiê ich wa¿nooci.
W ogólnym przypadku rozró¿niamy cztery podstawowe rodzaje komponentów:
Komponenty standardowe. S¹ one najczêociej u¿ywane przez programistów, dlatego wiêkszooæ z nich umieszczona jest na pierwszej karcie palety komponentów - karcie Standard.
Komponenty steruj¹ce. Nie s¹ one dostêpne w bibliotece standardowej.
Komponenty graficzne. S³u¿¹ do
wypisywania e tekstu
bezpoorednio na formularzu oraz do wyowietlania grafiki.
Komponenty niewidoczne. Staj¹ siê niewidoczne po uruchomieniu programu. Wszystkie komponenty z karty Dialogs oraz niektóre z kart System i Servers s¹ obiektami, które przestajemy widzieæ w dzia³aj¹cej aplikacji.
Na rysunku 5.1
pokazano fragment hierarchii obiektów biblioteki VCL. Tutaj Pprzedstawiony
zosta³ jedynie fragment drzewa obiektów Borland C++ Buildera 5, ale gdy¿
najlepszym sposobem zapoznania siê z ca³ooci¹ zagadnienia jest obejrzenie dosyæ
obszernego arkusza przedstawiaj¹cego wszystkie obiekty. Arkusz taki dostajemy
zawsze wraz z licencj¹ na kompilator.
Rys. 5.1. Dziedziczenie klas biblioteki VCL |
|
£atwo mo¿emy zauwa¿yæ, ¿e g³ówn¹ czêoæ drzewa powy¿szych obiektów stanowi szeoæ klas.
Jest przodkiem wszystkich typów obiektowych Borland C++ Builder 5. Najczêociej nie korzysta siê bezpoorednio z w³aociwooci i metod, które nam udostêpnia.
Wszystkie typy
obiektowe maj¹ce zdolnooæ pos³ugiwania siê
strumieniami przechowuj¹c swoje
egzemplarze pochodz¹ w³aonie od tej klasy
Klasa
ta która w rzeczywistooci nie definiuje
nowych w³aociwooci ani pól Ddefiniuje
natomiast destruktor ~TPersistent() oraz szeoæ metod:
Assign()-
metoda
przypisania e
obiektowi w³aociwooci i atrybutów innego obiektu
AssignTo()- metoda odwrotna do poprzedniej. Przypisuje danemu obiektowi kopiê w³asnych w³aociwooci i atrybutów.
DefineProperties()- ta metoda definiuje sposób przypisania strumieniowi pewnych dodatkowych w³aociwooci komponentu.
GetNamePath()- umo¿liwia odczytanie nazwy obiektu oraz jego ustalonych w³aociwooci w inspektorze obiektów.
GetOwner()- podaje w³aociciela obiektu.
TPersistent() tworzy nowy obiekt.
Z dok³adniejszym opisem oraz praktycznymi sposobami wykorzystania tych metod mo¿emy siê zapoznaæ siêgaj¹c do plików pomocy.
Z klasy tej pochodzi ka¿dy komponent C++ Buildera 5. Wprowadzone przez ni¹ w³aociwooci i metody pozwalaj¹ na obs³ugê komponentów poprzez inspektora obiektów. Z niektórymi z nich zapoznaliomy siê przy okazji tworzenia ostatniego projektu.
Komponenty wizualne
reprezentowane w tej klasie s¹ widoczne w czasie dzia³ania programu, chocia¿
istniej¹ sposoby by je ukryæ lub uczyniæ niewidocznymi w trakcie dzia³ania
programu. Obiekty tej klasy posiadaj¹ szereg w³aociwooci (z niektórymi z nich
zapoznaliomy siê ju¿ wczeoniej miêdzyczasie). Oto
niektóre z nich. Do najczêociej u¿ywanych nale¿¹:
Align
okreola my w jaki
sposób komponent ma byæ ustawiony na formularzu (obszarze klienta). Je¿eli np.
wybierzemy w inspektorze obiektów alClient, wówczas komponent ten
pokryje ca³y dostêpny obszar formularza. W³aociwooæ tego typu aktywna jest np.
dla komponentów typu TPanel TGroupBox czy TRadioGroup z karty Standard
Anchors okreola po³o¿enie komponentu w stosunku do jednego z rogów formularza.
Caption
opisuje
komponentu. Æwiczyliomy to ju¿ na przyk³adzie tytu³u
formularza czy chocia¿by opisu przycisków TButton
ClientHeight oraz ClientWidth okreola wymiary komponentu (wysokooæ i d³ugooæ) w obszarze klienta.
Color
ustalamy
kolor wype³nienia (wnêtrza) komponentu.
Cursor
wybieramy
okreola
postaæ kursora, który bêdzie widoczny w obszarze danego
komponentu.
DragKind oraz DragMode dzia³anie ich by³o pokazywane ju¿ w tej ksi¹¿ce[EK69]
Enabled
okreolamy, czy komponent bêdzie dla nas
dostêpny. Je¿eli pos³uguj¹c siê np. przyciskiem typu TButton napiszemy:
Button1->Enabled = FALSE;
pPrzycisk
bêdzie widoczny, ale nie bêdzie aktywny. Powrót do normalnej sytuacji mo¿liwy
jest dziêki:
Button1->Enabled = TRUE;
Analogicznych ustawieñ dokonamy te¿ przy pomocy inspektora obiektów.
Font
ustalamy
rodzaj czcionki napisów widocznych w obszarze komponentu.
Hint
ta
w³aociwooæ sprawia, ¿e mo¿na wpisaæ ujemy
"dymek podpowiedzi", ale wówczas ShowHint musi byæ ustalone jako TRUE
Height i Width okreolaj¹ rozmiar komponentu.
Text
dziêki
tej w³aociwooci tekst wyowietlany jest na w
obszarze komponentu. Stosujemy j¹ t¹ w³aociwooæ
m. in. m.in. do obiektów typu TEdit
Top Left okreolaj¹ odleg³ooci komponentu od krawêdzi odpowiednio górnej i lewej formularza (lub ogólnie innego komponentu, od którego wywodzi siê komponent, któremu cechy te przypisujemy).[EK70]
Visible okreola czy komponent ma byæ widoczny. Je¿eli w programie napiszemy:
Button1->Visible = FALSE;
komponent pozostanie ca³kowicie niewidoczny do czasu wywo³ania:
Button1->Visible = TRUE;
Czynnooæ ci
t
mo¿na równie¿
wykonaæ te¿ przy pomocy inspektora obiektów.
Klasa TControl udostêpnia nam równie¿ szereg po¿ytecznych zdarzeñ. Do najczêociej u¿ywanych nale¿¹:
OnClick
po klikniêciu w obszaru komponentu
zostanie wywo³ana funkcja obs³ugi wybranego zdarzenia. Mo¿na wyobraziæ sobie
sytuacjê, gdy mamy np. dwa przyciski typu TButton i z ka¿dym z
nich skojarzona jest funkcja odpowiedniego zdarzenia (takie operacje ju¿ nie s¹
dla nas tajemnic¹). Powiedzmy, ¿e chcemy szybko zamieniæ role tych przycisków,
tzn. aby klikniêcie na Button1 wywo³ywa³o
funkcjê obs³ugi zdarzenia Button2Click(), wówczas zaznaczaj¹c Button1, w inspektorze obiektów zamieniamy je po prostu rolami, tak jak
pokazuje to rysunek 5.2.
Rys. 5.2. Przypisanie przyciskowi Button1 funkcji obs³ugi zdarzenia skojarzonego z Button2 |
|
OnDblClick
dwukrotne klikniêcie w obszaru ze
komponentu spowoduje wywo³anie funkcji odpowiedniego zdarzenia.
OnResize
wywo³uje
anie np. funkcj i
obs³ugi zdarzenia po zmianie rozmiaru komponentu.
OnMouseDown
wywo³uje
reakcj a na zdarzenie
polegaj¹ce na klikniêciu e nad
komponentu. em.
OnMouseMove ka¿dy ruch myszk¹ nad komponentem wywo³a funkcjê odpowiedniego zdarzenia.
OnMouseUp jak wy¿ej, tyle ¿e w przypadku puszczenia przycisku muszki.
TControl udostêpnia nam równie¿ zdarzenia zwi¹zane z przesuwaniem komponentów przy pomocy myszki: OnDragOver OnDragDrop OnEndDrag OnStartDock czy OnStartDrag
Jako przyk³ad u¿ycia tych po¿ytecznych zdarzeñ niech nam pos³u¿y poni¿szy wydruk.
Wydruk 5.1. Idea pos³ugiwania siê zdarzeniami OnMouseMove oraz OnStartDock. W przyk³adzie tym ustawienia w³aociwooci przycisku Button1 musz¹ byæ podobne do tych z rysunku 4.6.
#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
void __fastcall TForm1::Button2Click(TObject *Sender)
void __fastcall TForm1::Button1StartDock(TObject *Sender,
TDragDockObject *&DragObject)
void __fastcall TForm1::Button1MouseMove(TObject *Sender,
TShiftState Shift, int X, int Y)
Formularz a
dzia³aj¹cej aplikacji powinien przedstawiaæ siê tak jak pokazuje
to rys. 5.3.
Rys. 5.3. Formularz dzia³aj¹cej aplikacji wykorzystuj¹cej zdarzenia OnMouseMove oraz OnStartDock udostêpniane przez klasê TControl |
|
Reprezentuje
nieaktywne komponenty wykorzystywane w ró¿nego rodzaju operacjach zwi¹zanych z
grafik¹. Bêd¹c wWidoczne ymi
na ekranie komponenty te mog¹
wyowietlaæ tekst lub grafikê. Z najpowszechniej stosowanych komponentów tego
typu nale¿y wymieniæ: TBevel TImage TPaintBox TShape TSpeedButton TSplitter oraz TCustomLabel, od
którego wywodz¹ siê z kolei TDBText i oraz TLabel. Komponenty tego rodzaju typu mog¹ nie tylko obs³ugiwaæ
zdarzenia, których Yród³em jest myszka, ale jak
równie¿ mog¹ byæ u¿ywane w funkcjach obs³ugi innych zdarzeñ. Jako przyk³ad
praktycznego wykorzystania e jednego z takich
komponentów TLabel niech nam pos³u¿y przyk³ad funkcji obs³ugi zdarzenia reaguj¹cego na
zmianê po³o¿enia myszki na formularzu:
void __fastcall TForm1::OnMoseMove(TObject *Sender, TShiftState Shift,
int X, int Y)
W wyniku,
na obszarze klienta zobaczymy odpowiedni napis oraz
aktualne wspó³rzêdne kursora myszki. Funkcja ta zosta³a zbudowana w bardzo
prosty sposób. Na W obszar
formularza przenios³em komponent typu TLabel. Nastêpnie, raz klikaj¹c na
formê, w karcie zdarzeñ inspektora obiektów wybra³em[EK71] OnMouseMove, któremu przypisa³em identyczn¹ nazwê. Dalej, Nastêpnie
przy pomocy klawisza Enter mog³em ¿na dostaæ siê
ju¿ do wnêtrza odpowiedniej funkcji. Wartooci numeryczne wspó³rzêdnych zosta³y
zamienione na tekst przy pomocy wielce u¿ytecznej funkcji:
extern PACKAGE AnsiString __fastcall IntToStr(int Value);
Funkcja ta konwertuje Konwertuj¹cej
dane typu int[EK72] na dane typu AnsiString. [EK73]Zauwa¿my te¿, ¿e wykorzystaliomy tutaj w³aociwooæ Caption[EK74] okreolaj¹c¹ ³añcuch znaków wyowietlanych na komponencie.
Wszystkie okna
edycyjne, listy wyboru, przyciski itp. s¹ S
obiektami potomnymi tej klasy. Komponenty okienkowe mog¹ byæ
aktywne, posiadaj¹ swoje w³asne identyfikatory oraz mo¿liwooæ przewijania.
Klasa ta posiada szereg w³aociwooci, metod i zdarzeñ. Wykorzystanie kilku z
nich prezentuje poni¿szy przyk³ad:
void __fastcall TForm1::Button1Click(TObject *Sender)
W wyniku
cyklicznego (cyklicznych klikniêæ myszk¹ na przycisk Button1) wywo³ywania funkcji obs³ugi zdarzenia Button1Click()
zauwa¿ymy, ¿e w oknie edycji Memo1 pojawi siê pewien napis, ponadto
bêdzie on przewijany w tym oknie. Równie¿ ca³y obszar klienta formularza bêdzie
siê przemieszcza³. Dokonamy tego korzystaj¹c z metody Jest to
mo¿liwe dziêki metodzie ScrollBy(), która przesuwa ca³e okno
dodaj¹c do jego aktualnych wspó³rzêdnych wartooci argumentów, z którymi
metod¹ t¹ wywo³aliomy[EK75]. Z innych ciekawych metod nale¿y wymieniæ CanFocus()
sprawdzaj¹c¹, czy dany komponent okienkowy mo¿e byæ uaktywniony, Focused()
sprawdzaj¹c¹ czy okienko jest aktywne i wreszcie SetFocus()
uaktywniaj¹c¹ wybrany komponent okienkowy. Aktywny komponent powinien reagowaæ
na zdarzenia (np. klikniêcie w jego obszaru ze).
Je¿eli nie chcemy zbyt czêsto u¿ywaæ myszki, zawsze mo¿na przenieoæ aktywnooæ z
jednego okienka do drugiego w zupe³nie inny sposób. Na przyk³ad, pracuj¹c w
okienku Memo1 zapragniemy nagle, by okno Memo2 sta³o siê aktywne, wówczas w
odpowiednim miejscu kodu wystarczy wpisaæ:
Memo2->SetFocus();
Lub, gdy jak¹o operacjê uzale¿niamy od tego, czy dane okienko jest aktywne, mo¿emy u¿yæ prostej konstrukcji:
void __fastcall TForm1::Memo2Change(TObject *Sender)
Przyk³adem
w³aociwooci udostêpnianych przez TWinControl i wykorzystanych ju¿ przez
nas bêd¹ Brush ustalaj¹cy kolor
wype³nienia, a tak¿e ClientRect i oraz Left przesuwaj¹ce komponent do prawego [EK76]rogu formularza.
Zdarzenia
udostêpniane przez wymienion¹ klasê w stosunku do komponentów okienkowych
obs³ugiwane s¹ z poziomu klawiatury oraz
przy pomocy myszki oraz m Mo¿liwe
jest równie¿ przenoszenie aktywnooci pomiêdzy okienkami. Do najwa¿niejszych
zdarzeñ generowanych z poziomu klawiatury nale¿¹: OnKeyPress OnKeyDown OnKeyUp oraz OnEnter i OnExit
Jako przyk³ad ich wykorzystania poka¿my jak mo¿na zmieniaæ kolor obszaru komponentu okienkowego, np. TMemo
void __fastcall TForm1::OnEnterMemo1(TObject *Sender)
void __fastcall TForm1::OnExitMemo2(TObject *Sender)
void __fastcall TForm1::OnEnterMemo2(TObject *Sender)
Oczywiocie, nale¿y pamiêtaæ, ¿e zdarzenie OnExit dzia³a najlepiej w odpowiedzi na nacioniêcie tabulatora (Tab
W rozdziale tym dokonano krótkiego
przegl¹du podstawowych elementów biblioteki VCL. Krótko zosta³y omówione
najwa¿niejsze klasy dostêpne w tej bibliotece. Parê po¿ytecznych przyk³adów
opisuj¹cych sposoby praktycznego wykorzystania metod w³aociwooci i zdarzeñ
udostêpnianych przez poszczególne klasy pomo¿e nam
zrozumieæ ideê korzystania z biblioteki VCL.
Najwa¿niejszym elementem orodowisk programistycznych dla Windows, takich jak Delphi czy Builder jest biblioteka wizualnych komponentów. W ogólnooci, korzystaj¹c z Borland C++Buildera 5 mo¿emy pos³ugiwaæ siê dziewiêtnastoma paletami takich komponentów:
Standard components
Additional components
Win32 components
System components
Data Access components
Data Controls components
ADO components
InterBase components
MIDAS components
InternetExpress components
Internet components
FastNet components
Decision Cube components
QReport components
Dialogs components
Win 3.1 components
Samples components
ActiveX components
Servers components
W wersji Standard mamy do dyspozycji dziesiêæ kart zawieraj¹cych najczêociej u¿ywane komponenty. Nie jest oczywiocie mo¿liwe, aby w opracowaniu o niewielkich rozmiarach szczegó³owo opisaæ ka¿dy komponent z uwzglêdnieniem jego cech, metod i zdarzeñ, nawet je¿eli pracujemy w standardowej wersji C++Buildera 5. Wa¿nym uzupe³nieniem musz¹ byæ dla nas pliki pomocy Buildera. Sprowadzaj¹c jakio komponent do obszaru formularza zawsze mo¿emy pos³u¿yæ siê klawiszem F1, aby otrzymaæ naprawdê wyczerpuj¹c¹ informacjê na temat klasy, do jakiej nale¿y wybrany komponent, jego w³aociwooci, itp. Poruszaj¹c siê po niezwykle bogatych w treoci plikach pomocy, przy odrobinie wysi³ku znajdziemy tam równie¿ bardzo wiele po¿ytecznych przyk³adów praktycznego pos³ugiwania siê okreolonymi obiektami. Obecnie zapoznamy siê z kilkoma najczêociej u¿ywanymi kartami.
Korzystaj¹c z zasobów tej karty mamy do dyspozycji wszystkie najczêociej wykorzystywane komponenty reprezentuj¹ce sob¹ wszystkie podstawowe elementy steruj¹ce Windows. [EK77]
Tabela 6.1. Komponenty karty Standard
Ikona |
Typ |
Znaczenie |
|
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
TFrames |
"Ram |
|
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
TMainMenu |
Komponent
pomocny w procesie projektowania i tworzenia g³ównego menu aplikacji; |
|
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
TPopupMenu |
Ten
komponent |
|
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
TLabel |
W polu tej etykiety mo¿emy wyowietlaæ tekst. |
|
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
TEdit |
Komponent edycyjny, nazywany polem edycji, w którym mo¿emy wyowietliæ jeden wiersz tekstu. |
|
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
TMemo |
Ten
komponent |
|
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
TButton |
Przycisk. |
|
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
TCheckBox |
Komponent reprezentuj¹cy pole wyboru. Posiada w³aociwooæ Checked, która mo¿e reprezentowaæ dwa stany: w³¹czony TRUE lub wy³¹czony FALSE |
|
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
TRadioButton |
Umo¿liwia dokonanie wyboru tylko jednej spooród wielu opcji. Komponent ten powinien wystêpowaæ w grupie podobnych komponentów reprezentuj¹cych pewne opcje aplikacji, z których mo¿emy wybraæ tylko jedn¹. |
|
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
TListBox |
Komponent pomocny w tworzeniu listy elementów, które nastêpnie mo¿emy dowolnie zaznaczaæ i wybieraæ. |
|
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
TComboBox |
Ten
komponent tak¿e wykorzystywany jest do tworzenia listy elementów, jednak
posiadaj¹c |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
TScrollBar |
Ten
komponent |
|
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
TGroupBox |
W obszarze tego komponentu mo¿emy pogrupowaæ inne elementy, np. TRadioButton czy TCheckBox. Posiada ciekaw¹ w³asnooæ w postaci linii tytu³owej, w której mo¿emy wpisaæ np. nazwê danego obszaru formularza. |
|
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
TRadioGroup |
Komponent grupuj¹cy elementy typu TRadioButton. Równie¿ posiada w³asn¹ liniê tytu³ow¹. |
|
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
TPanel |
Reprezentuje panel, na którym mo¿emy umieszczaæ inne komponenty. Posiadaj¹c rozbudowane w³asnooci "estetyczne" doskonale nadaje siê do roli paska narzêdzi lub linii statusu. |
|
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
TActionList |
Komponent ten potocznie nazywany jest "organizatorem pisania oraz dzia³ania aplikacji". W wygodny sposób udostêpnia nam zestawy akcji, pozwalaj¹ce na wywo³ywanie funkcji obs³ugi zdarzeñ w okreolonej sekwencji. Umo¿liwia te¿ (wspólnie z TImageList znajduj¹cym siê na karcie Win32) bardzo estetyczne zaprojektowanie menu aplikacji. |
Zastosowanie TFramesÆwiczenie 6.1. Poleceniem menu File|New Frame stwórzmy obiekt ramki. powinna byæ automatycznie przypisana nazwa Frame2 ponadto powinien byæ on widoczny w obszarze g³ównego formularza. Zauwa¿my, ¿e Frame2 posiada wiêkszooæ cech g³ównego formularza, ³¹cznie z obszarem klienta. Ju¿ teraz mo¿emy ustaliæ niektóre jej cechy, np. DragKind oraz DragMode tak jak pokazuje to rys. 4.6. W obszarze ramki rozmieoæmy trzy komponenty klasy TEdit oraz jeden TButton. Cechy Text komponentów reprezentowanych przez Edit1 Edit2 oraz Edit3 wyczyoæmy. Cechê Name przycisku Button1 zmieñmy na &Dodaj. Rozmieszczenie poszczególnych elementów w obszarze obiektu TFrames reprezentowanego przez Frame2 i potocznie nazywanego ramk¹ powinno byæ podobne jak na rys. 6.1.
Teraz dodajmy void __fastcall TFrame2::Button1Click(TObject *Sender) catch(...) Funkcje StrToFloat() dokonaj¹ konwersji ci¹gu znaków przechowywanych w cechach Text komponentów Edit1 oraz Edit2 na
zmiennopozycyjn¹ postaæ numeryczn¹, czyli po prostu na liczby z przecinkami.
U¿ywaj¹c prostego operatora " " te dwie wartooci dodamy do siebie,
zao wynik dzia³ania zostanie z kolei przypisany cesze Text komponentu edycyjnego reprezentowanego przez Edit3. Aby postaæ numeryczna liczby mog³a byæ wyowietlona w oknie edycyjnym
musi zostaæ zamieniona na ³añcuch znaków (najlepiej typu AnsiString). Dokonamy tego stosuj¹c funkcjê FloatToStr()konwertuj¹c¹
postaæ numeryczn¹ try // "próbuj" wykonaæ operacjê catch(...) // je¿eli operacja nie powid³a siê "przechwyæ wyj¹tek" W naszym prostym przyk³adzie wyj¹tkiem bêdzie albo nie wpisanie liczb(y) w ogóle do komponentów edycyjnych, albo wpisanie znaku nie bêd¹cego liczb¹. Chocia¿ jest to bardzo prosty przyk³ad korzystania z wyj¹tków, jednak powinniomy staraæ siê zrozumieæ ich naturê. Wyj¹tki s¹ równie¿ obiektami Windows pe³ni¹c tam bardzo wa¿n¹ rolê. Je¿eli takowy wyj¹tek wyst¹pi, odpowiedni komunikat poka¿emy w postaci okienka z przyciskiem korzystaj¹c z funkcji ShowMessage() W taki oto sposób przygotowaliomy obiekt ramki. Nale¿y obecnie w³¹czyæ go do naszego formularza. To, ¿e ramka jest wyowietlana na formularzu jeszcze nic nie znaczy, musimy j¹ jawnie do³¹czyæ do projektu. Dokonamy tego w³aonie dziêki komponentowi Frames z karty Standard. W tym celu kliknijmy na obszar g³ównego formularza, ramka powinna siê "schowaæ", nastêpnie wybierzmy z karty opcjê Frames i ponownie kliknijmy na formularzu. Wynik naszego dzia³ania powinien przybraæ postaæ pokazan¹ na rys. 6.2.
Potwierdzaj¹c
przyciskiem OK. uzyskamy po¿¹dany
efekt. Frame2 od tej pory stanie siê obiektem sk³adowym naszej aplikacji. Ju¿ teraz
mo¿emy obejrzeæ dyrektywy prekompilatora [EK78]w module g³ównego projektu. Pojawi³a siê tam dyrektywa #pragma link
"Unit2", co
oznacza, ¿e konsolidator do³¹czy ten plik do g³ównego projektu. Domyol Pozostaje nam ju¿ teraz zaprojektowaæ dwa proste zdarzenia reprezentuj¹ce zamkniêcie aplikacji oraz ewentualnie ponowne wyowietlenie ramki (przydatne, gdy ramkê zamkniemy korzystaj¹c z jej w³asnego pola zamkniêcia). W tym celu umieoæmy na formularzu dwa komponenty typu TButton i przypiszmy im funkcje obs³ugi odpowiednich zdarzeñ. Kod Yród³owy modu³u naszego projektu pokazany jest na wydruku 6.1, zao rysunek 6.3 przedstawia dzia³aj¹c¹ aplikacjê. Wydruk 6.1. Modu³ Unit1.cpp aplikacji Projekt05.dpr. #include <vcl.h> #pragma hdrstop #include "Unit1.h" #pragma package(smart_init) #pragma link "Unit2" #pragma resource "*.dfm" TForm1 *Form1; __fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) //---------zamyka ca³¹ aplikacjê-------- ----- ------ ----- void __fastcall TForm1::Button1Click(TObject *Sender) //----------uaktywnia Frame2-------- ----- ------ --------- void __fastcall TForm1::Button2Click(TObject *Sender)
Obs³uga programu
sprowadza siê do wprowadzenia z klawiatury dwóch liczb i wykonania Wykorzystanie pozosta³ych komponentów karty StandardAby zilustrowaæ w³aociwooci niektórych pozosta³ych komponentów
stworzymy przyk³adow¹ aplikacjê w postaci dosyæ z³o¿onego okienka. G³ównym Formularz naszej aplikacji, nazwijmy j¹ Projekt06.bpr ,sk³adaæ
siê bêdzie z pojedynczych pól edycji TEdit i TMemo. W ich
reprezentantach, Edit1 oraz Memo1 bêdziemy
odpowiednio wpisywali nazwê pliku do odczytu oraz wyowietlali jego zawartooæ.
Aby zawartooæ pliku ³adnie siê wyowietla³a, cechê WordWrap obiektu Memo1 ustalmy jako TRUE, wówczas tekst bêdzie siê zwija³ w okienku. Ponadto, w przypadku
odczytu wiêkszego pliku, dobrze by by³o mieæ do dyspozycji
mo¿liwooæ jego przewijania w okienku. Uzyskamy to ustalaj¹c dla cechy
ScrollBars void __fastcall TForm1::CheckBox1Click(TObject *Sender) void __fastcall TForm1::CheckBox2Click(TObject *Sender) których wykonanie spowoduje, ¿e bêdziemy mogli zmieniæ krój czcionki oraz jej kolor w tekocie wyowietlanym w Memo1. Dokonaliomy pierwszych przypisañ w naszym projekcie. Zawsze dobrym zwyczajem jest sprawdzenie ich poprawnooci. Aby tego dokonaæ musimy niestety w jakio sposób wczytaæ wybrany plik (lub wpisaæ coo z klawiatury). Nie przejmujmy siê, ¿e tym razem zrobimy to nieco "na piechotê". C++Builder posiada oczywiocie odpowiednie narzêdzia pozwalaj¹ce na pe³n¹ automatyzacjê podobnych czynnooci, niemniej jednak przypomnienie sobie paru istotnych pojêæ zwi¹zanych z plikami na pewno nikomu z nas nie zaszkodzi.
Wczytujemy plik z dyskuPlik, którego pe³n¹
nazwê wraz z rozszerzeniem bêdziemy w tym konkretnym przypadku wpisywaæ rêcznie
w okienku Edit1, wczytamy pos³uguj¹c siê jednym ze sposobów w³aociwych dla C++, tzn.
najpierw plik otworzymy do odczytu korzystaj¹c z funkcji FileOpen() Wydruk 6.2. Funkcja obs³ugi zdarzenia Button1Click() wykorzystywana w projekcie Projekt06.bpr // --- wczytanie pliku void __fastcall TForm1::Button1Click(TObject *Sender) else
Komponenty TRadioGroup oraz TScrollBarSposób
wykorzystywania
I oczywiocie potwierdziæ. Nastêpnie w opcjê Columns (inspektor obiektów) wpiszemy , zao do ItemIndex wstawimy (pamiêtajmy, ¿e numeracja opcji zaczyna siê od 0). Wystarczy teraz klikaj¹c dwa razy dostaæ siê do wnêtrza funkcji obs³ugi zdarzenia RadioGroup1Click() i wype³niæ j¹ odpowiednim kodem. Przy okazji od razu mo¿emy w³¹czyæ do programu komponent reprezentowany przez ScrollBar1 z wykorzystaniem jego cechy Position, tak jak pokazano poni¿ej: void __fastcall TForm1::ScrollBar1Change(TObject *Sender) void __fastcall TForm1::RadioGroup1Click(TObject *Sender) Poprawnooæ zastosowanych przypisañ nale¿y oczywiocie (najlepiej od razu) przetestowaæ. Komponenty TMainMenu oraz TPopupMenuZajmijmy siê teraz
obiektami, przy pomocy których bêdziemy tworzyæ opcje menu zarówno g³ównego,
jak i kontekstowego. Aby dostaæ siê do okna s³u¿¹cego do tworzenia menu
g³ównego nale¿y zaznaczyæ komponent MainMenu1, a nastêpnie dwukrotnie klikn¹æ myszk¹
Sposób tworzenia
menu kontekstowego nie ró¿ni siê w istocie od tego co ju¿
powiedzieliomy na temat menu g³ównego. Aby wygl¹da³o ono tak jak pokazuje
rysunek 6.7 nale¿y cechy Caption poszczególnych jego opcji zmieniæ odpowiednio na Niebieski Czerwony Zielony i Przywróæ kolory, zao
cechy Name odpowiednio na Blue Red Green oraz BtnFace. Teraz w karcie Events ka¿demu z nich wystarczy
przypisaæ zdarzenia BlueClick RedClick GreenClick oraz BtnFaceClick. Klikaj¹c dwukrotnie
TPanel oraz TCheckBoxPokazany na rysunku
6.4 sposób umieszczenia na formularzu reprezentantów klas TPanel oraz TCheckBox nie powinien stanowiæ dla nas problemu.
Pamiêtajmy Przyk³adowa aplikacjaWydruk 6.3 przedstawia kompletny kod g³ównego modu³u naszej aplikacji. Obs³uga programu sprowadza siê do wpisania z klawiatury w oknie edycji Edit1 nazwy pliku wraz z rozszerzeniem, który chcemy obejrzeæ. Pamiêtaæ jednak nale¿y, i¿ w naszym algorytmie nie zastosowaliomy ¿adnych opcji umo¿liwiaj¹cych programowi rozró¿nianie wielkooci wpisywanych liter. Dlatego nazwê wczytywanego pliku nale¿y wpisaæ z ewentualnym uwzglêdnieniem ma³ych i du¿ych liter. Wydruk 6.3. Kompletny kod modu³u Unit06.cpp projektu Projekt06.bpr #include <vcl.h> #include <stdio.h> #pragma hdrstop #include "Unit06.h" #pragma package(smart_init) #pragma resource "*.dfm" TForm1 *Form1; __fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) void __fastcall TForm1::ScrollBar1Change(TObject *Sender) void __fastcall TForm1::FormCreate(TObject *Sender) void __fastcall TForm1::Form1MouseDown(TObject *Sender, TMouseButton Button, TShiftState Shift, int X, int Y) void __fastcall TForm1::Button1Click(TObject *Sender) else void __fastcall TForm1::ApplicationCloseClick(TObject *Sender) void __fastcall TForm1::CheckBox1Click(TObject *Sender) void __fastcall TForm1::CheckBox2Click(TObject *Sender) void __fastcall TForm1::RadioButton1Click(TObject *Sender) void __fastcall TForm1::RadioButton2Click(TObject *Sender) void __fastcall TForm1::RadioButton3Click(TObject *Sender) void __fastcall TForm1::RadioGroup1Click(TObject *Sender) void __fastcall TForm1::BlueClick(TObject *Sender) void __fastcall TForm1::RedClick(TObject *Sender) void __fastcall TForm1::GreenClick(TObject *Sender) void __fastcall TForm1::BtnFaceClick(TObject *Sender) Æwiczenie do samodzielnego wykonaniaÆwiczenie 6.2. Postaraj siê umieociæ na formularzu obok menu Plik inne menu, np. Kolory. Zaprojektuj zdarzenia tego menu w ten sposób, by mo¿na by³o dziêki nim zmieniaæ t³o obiektu Mamo1 Hierarchia w³asnooci obiektów
|
|
Nale¿y rozró¿niaæ pojêcia w³aociciela (Owner) i rodzica (Parent). Rodzic nie jest to¿samy z w³aocicielem. W³aociciela okreola siê tylko raz podczas wywo³ywania jego konstruktora i nie mo¿na ju¿ go zmieniæ bez zniszczenia obiektu. Rodzica obiektu mo¿emy natomiast zmieniæ zawsze. |
Przedstawione powy¿ej wiadomooci
na temat w³asnooci w³aocicielstwa
i rodzicielstwa obiektów stanowi¹ tylko wierzcho³ek góry lodowej. Byæ mo¿e dla
niektórych z nas wyda siê to nieco zaskakuj¹ce, ale mamy te¿ mo¿liwooæ
samodzielnego tworzenia i umieszczania na formularzu ró¿nych obiektów (dostêpnych
oczywiocie w bibliotece VCL). Musimy wiedzieæ, ¿e ka¿dy taki obiekt posiada
swojego w³asnego konstruktora jednak opis tego zagadnienia nie
mieoci siê w ramach tej ksi¹¿ki.
Æwiczenie 6.3.
Umieoæ na formularzu komponent typu TPanel, na nim zao jeszcze parê innych komponentów widzialnych (mog¹ byæ umieszczone na zasadzie piramidki). Postaraj siê samodzielnie okreoliæ relacje w³aocicielstwa i rodzicielstwa pomiêdzy nimi.
Karta Additional jest rozszerzeniem karty Standard. Zawiera szereg komponentów, które okazuj¹ siê bardzo przydatne w projektowaniu aplikacji.
Tabela 6.2. Komponenty karty Additional
Ikona |
Typ |
Znaczenie |
|
TBitBtn |
Przycisk, na którym mo¿na umieszczaæ rysunek. |
|
TSpeedButton |
Przycisk umieszczany zwykle na pasku zadañ. Na nim równie¿ mo¿emy umieszczaæ rysunki. |
|
TMaskEdit |
Komponent s³u¿¹cy do maskowania i filtrowania danych wpisywanych zwykle z klawiatury. |
|
TStringGrid |
Element,
|
|
TDrawGrid |
Element,
który |
|
TImage |
Komponent graficzny. Umo¿liwia wyowietlenie na formularzu np. mapy bitowej. |
|
TShape |
Ten
element |
|
TBevel |
Sk³adnik, |
|
TScrollBox |
Komponent zawieraj¹cy paski przewijania. Mo¿e pe³niæ rolê przewijanego okienka. |
|
TCheckListBox |
Element
stanowi¹cy |
|
TSplitter |
Ten
komponent |
|
TStaticText |
Sk³adnik,który
|
|
TControlBar |
Komponent,
który |
|
TApplicationEvents |
Komponent umo¿liwiaj¹cy przechwytywanie zdarzeñ generowanych przez aplikacjê, w tym równie¿ wyj¹tków. |
|
TChart |
Ten
sk³adnik |
Karta zawiera wszystkie elementy steruj¹ce reprezentowane w aplikacjach Windows.
Tabela 6.3. Komponenty karty Win32
Ikona |
Typ |
Znaczenie |
|
TTabControl |
Korzystaj¹c z tego komponentu mamy mo¿liwooæ tworzenia zak³adek. |
|
TPageControl |
Komponent sk³adaj¹cy siê z wiêkszej ilooci kart. Aby stworzyæ now¹ kartê w najprostszym przypadku nale¿y nacisn¹æ prawy klawisz myszki i wybraæ opcjê New Page |
|
TImageList |
Ten
sk³adnik |
|
TTrackBar |
Suwak. Posiada cechê Position, dziêki której mo¿na regulowaæ i odczytywaæ aktualn¹ pozycjê wskaYnika przesuwania. |
|
TProgressBar |
Komponent bêd¹cy wskaYnikiem postêpu. Równie¿ posiada cechê Position, dziêki której mo¿emy oledziæ postêp wykonywanych operacji. |
|
TUpDown |
Komponent umo¿liwiaj¹cy zwiêkszanie b¹dY zmniejszanie jakiejo wartooci. Z regu³y nie wystêpuje samodzielnie. Wartooci nale¿y wyowietlaæ w komponentach edycyjnych. Równie¿ posiada cechê Position |
|
THotKey |
Element |
|
TAnimate |
Komponent,
który |
|
TDateTimePicker |
Komponent bêd¹cy w istocie pewnego rodzaju kalendarzem. Umo¿liwia odczytanie i wybranie odpowiedniej daty. Posiada rozwijany obszar podobny do TListBox |
|
TMonthCalendar |
Komponent bardzo
podobny do poprzedniego, z t¹ ró¿nic¹, ¿e wyowietla od razu |
|
TTreeView |
Sk³adnik
powoduj¹cy |
|
TListView |
Lista widoków wyowietla pozycje sk³adaj¹ce siê z ikon i etykiet. |
|
THeaderControl |
Komponent tworz¹cy listê nag³ówkow¹ mog¹c¹ sk³adaæ siê z wielu sekcji. |
|
TStatusBar |
Linia statusu
formularza. Aby umieociæ odpowiedni tekst w linii statusu
formularza, |
|
TToolBar |
Komponent,
który |
|
TCoolBar |
Komponent bêd¹cy pewn¹ odmiana panelu, z t¹ ró¿nic¹, ¿e pozwala na zmianê jego rozmiaru. |
|
TPageScroller |
Ten
sk³adnik |
Karta System zawiera szereg komponentów wykorzystywanych w ró¿nych operacjach na poziomie systemu Windows.
Tabela 6.4. Komponenty karty System
Ikona |
Typ |
Znaczenie |
|
TTimer |
Jest komponentem niewidzialnym. S³u¿y do generowania zdarzeñ w równych odstêpach czasu. |
|
TPaintBox |
Komponent wykorzystywany do wykonywania ró¿nych operacji graficznych. |
|
TMediaPlayer |
Komponent,
który |
|
TOleContainer |
Jest komponentem
niewidocznym. S³u¿y do generowania na formularzu obszaru |
|
TDDEClientConv |
Komponent
niewidzialny. Umo¿liwia po³¹czenie z serwerem
DDE. |
|
TDDEClientItem |
Komponent
niewidzialny. Okreola dane wysy³ane przez klienta podczas
konwersacji DDE. |
|
TDDEServerConv |
Niewidzialny komponent umo¿liwiaj¹cy nawi¹zanie dialogu z klientem DDE. |
|
TDDEServerItem |
Komponent
niewidzialny. Umo¿liwia okreolenie danych wysy³anych do klienta
w trakcie konwersacji DDE. |
Komponenty Karty Dialogs reprezentuj¹ standardowe okna
dialogowe Windows. Bêd¹ to, np. okna do zapisu pliku, odczytu,
drukowania, wyboru rodzaju czcionki czy palety kolorów. Wszystkie s¹ komponentami
niewidzialnymi.
Tabela 6.5. Komponenty karty Dialogs
Ikona |
Typ |
Znaczenie |
|
TOpenDialog |
Komponent tworz¹cy okienko dialogowe s³u¿¹ce do wyboru i otwarcia pliku. |
|
TSaveDialog |
Komponent tworz¹cy okienko dialogowe s³u¿¹ce do zapisu danych do pliku. |
|
TOpenPictureDialog |
Sk³adnik
|
|
TSavePictureDialog |
Komponent tworz¹cy okienko dialogowe s³u¿¹ce do zapisu pliku graficznego. |
|
TFontDialog |
Komponent,
który |
|
TColorDialog |
Okienko dialogowe s³u¿¹ce do wyboru palety kolorów. |
|
TPrintDialog |
Okienko |
|
TPrinterSetupDialog |
Komponent
okreolaj¹cy |
|
TFindDialog |
Komponent s³u¿¹cy do podgl¹du i wyszukiwania tekstu. |
|
TReplaceDialog |
Okienko |
Jako po¿yteczny przyk³ad wykorzystania niektórych komponentów z omówionych ju¿ kart palety komponentów VCL, wykonamy prost¹ aplikacjê wczytuj¹c¹ wybrany plik z dysku i wyowietlaj¹c¹ jego zawartooæ w obiekcie edycyjnym TRichEdit. Postaramy siê jednak przy tej okazji zaprojektowaæ naprawdê "profesjonalne" menu.
Æwiczenie 6.4.
Za³ó¿my na dysku oddzielny katalog, powiedzmy, ¿e nazwiemy go \Projekt07.
Je¿eli w katalogu, w którym zainstalowaliomy Buildera istnieje podkatalog \Buttons, odszukajmy go i wybierzmy 7 map bitowych pokazanych poni¿ej. Przekopiujmy je do naszego katalogu. Je¿eli zao nie jesteomy w stanie ich odszukaæ, nale¿y skorzystaæ z edytora graficznego pokazanego na rys. 1.25. Postarajmy siê samodzielnie wykonaæ podobne obrazki (zapisuj¹c je oczywiocie w formacie mapy bitowej).
|
|
|
|
|
| |
Nowy |
Otwórz |
Zapisz jako |
Cofnij |
Wytnij |
Kopiuj |
Wklej |
Zaprojektujmy formularz, w którego sk³ad wchodziæ bêdzie komponent typu TToolBar, 7 przycisków TSpeedButton, okno edycji TRichEdit, przycisk typu TButton, menu TMainMenu, komponenty TSaveDialog i TOpenDialog, komponent TImageList oraz dwa komponenty TActionList. Sposób ich rozmieszczenia na formularzu pokazany jest na rysunku 6.8.
Rys. 6.8. Sposób rozmieszczenia komponentów na formularzu projektu Projekt07.bpr |
|
Najpierw na formularzu umieoæmy komponent TToolBar, zao bezpoorednio na nim kolejno komponenty TSpeedButton. Pos³uguj¹c siê inspektorem obiektów ich cechy Name zmieñmy odpowiednio na FileNew FileOpen FileSave Cut Copy Paste Undo
Korzystaj¹c z w³aociwooci Glyph, R rozwiñmy opcjê
TBitmap i umieoæmy na ka¿dym z tych przycisków odpowiedni¹ mapê bitow¹, tak
jak na rys. 6.8.
Ka¿demu z naszych komponentów
przyporz¹dkujemy funkcjê obs³ugi odrêbnego
zdarzenia wed³ug poni¿szego schematu:
void __fastcall TForm1::FileNewClick(TObject *Sender)
void __fastcall TForm1::FileOpenClick(TObject *Sender)
void __fastcall TForm1::FileSaveAsClick(TObject *Sender)
void __fastcall TForm1::UndoClick(TObject *Sender)
void __fastcall TForm1::CutClick(TObject *Sender)
void __fastcall TForm1::PasteClick(TObject *Sender)
void __fastcall TForm1::CopyClick(TObject *Sender)
Cechê Name komponentu ImageList1 zmieñmy na MenuImages Klikaj¹c go na nim dwukrotnie wczytajmy
kolejno potrzebne nam obrazki w postaci map bitowych, ka¿demu z nich
automatycznie powinien zostaæ przyporz¹dkowany kolejny numer:
Rys. 6.9. Sposób pos³ugiwania siê komponentem TToolBarImages |
|
Cechê Images (inspektor obiektów, karta Properties) komponentów ActionList1 oraz ActionList2 ustawmy jako MenuImages
Klikaj¹c dwukrotnie na
ActionList1 dostajemy siê do jego pola edycji komponentu.
Wybieraj¹c New
Action zmieniamy kategoriê (Categories) na File. Zaznaczaj¹c File dostajemy siê do okna akcji Actions, zmieniamy Action1 na FileNewcmd, któremu
przypisujemy temu komponentowi zerowy indeks
obrazka (ImageIndex
0), zao w opcji Events zdarzeniu OnExecute przypisujemy FileNewClick(). Podobne
dzia³ania trzeba przeprowadziæ ie post¹pmy z
innymi obiektami akcji, tak jak pokazuje to rys. 6.10.
Rys. 6.10. Ustalenie sposobu przypisañ w³aociwooci dla komponentów kategorii File |
|
|
W ten sam sposób akcji FileExitcmd przypisujemy funkcje obs³ugi zdarzenia
CloseApplicationClick(),skojarzonej z przyciskiem Button1, którego cechê
Name zmieniliomy na CloseApplication, zao cechê Caption na &Zamknij
11. Analogicznie projektujemy w³aociwooci komponentów kategorii Edit, ukrywaj¹cej
siê w ActionList2 tak jak pokazuje to rysunek 6.11.
Rys. 6.11. Ustalenie sposobu przypisañ w³aociwooci dla komponentów kategorii Edit |
|
|
Przechodzimy do zaprojektowania g³ównego menu. W karcie w³aociwooci inspektora obiektów, cesze Images komponentu TMainMenu przypiszmy MenuImages
G³ówne menu sk³adaæ siê bêdzie z dwóch opcji Plik oraz Edycja. Menu Plik zaprojektujemy w sposób pokazany na rysunku 6.12.
Rys.
6.12. Menu Plik wraz |
|
|
Je¿eli zechcemy, aby w odpowiedzi na wybranie opcji Nowy wywo³ywana by³a funkcja obs³ugi zdarzenia FileNewClick(), w karcie
zdarzeñ zdarzeniu OnClick w karcie zdarzeñ nale¿y w³aonie
przypisaæ FileNewClick
Z kolei menu Edycja zaprojektujemy wed³ug przepisu pokazanego na rysunku 6.13.
Rys.
6.13. Menu Edycja wraz |
|
|
Na wydruku 6.4 zamieszczono kompletny kod aplikacji Projekt07.bpr. W funkcji FormCreate() wykorzystaliomy w³aociwooci InitialDir oraz Filter obiektów TOpenDialog i TSaveDialog, z których pierwsza pozwala ju¿ w momencie uruchomienia aplikacji ustaliæ w³aociw¹ ocie¿kê dostêpu do aktualnego katalogu, z kolei druga z wymienionych zapewnia mo¿liwooæ odczytania plików posiadaj¹cych wymagane przez nas rozszerzenia. W tej samej funkcji umieociliomy równie¿ "dymki podpowiedzi" do poszczególnych przycisków, korzystaj¹c z w³aociwooci Hint oraz ShowHint. Oledz¹c poni¿szy wydruk zauwa¿ymy te¿, ¿e aby komponenty TOpenDialog i TsaveDialog niewidoczne przecie¿ w trakcie uruchomienia programu generowa³y zdarzenia polegaj¹ce na wyowietleniu odpowiednich okien dialogowych nale¿y w funkcjach odpowiednich zdarzeñ skorzystaæ z metody Execute(). Plik z dysku odczytujemy korzystaj¹c z metody LoadFromFile(), zapisujemy zao przy pomocy SaveToFile()
W funkcji CheckFileSave() skorzystaliomy z w³aociwooci Modified komponentów edycyjnych, w tym równie¿ klasy TRichEdit. Je¿eli wykonamy jak¹kolwiek modyfikacjê okna edycji, nast¹pi wywo³anie metody:
virtual void __fastcall Modified(void) = 0 ;
któr¹ nale¿y obs³u¿yæ, chocia¿by w sposób zaprezentowany poni¿ej. Je¿eli zdecydujemy siê zapisaæ zmiany, zostanie wywo³ana funkcja obs³ugi zdarzenia FileSaveAsClick(this), w przeciwnym wypadku nast¹pi wywo³anie funkcji Abort() wstrzymuj¹cej wykonywania bie¿¹cego zdarzenia.
|
W jêzyku C++ istnieje s³owo kluczowe this, bêd¹ce wa¿nym elementem wielu tzw. "prze³adowywanych operatorów". Ka¿da funkcja sk³adowa aplikacji lub ogólnie obiektu w momencie wywo³ania uzyskuje automatycznie wskaYnik do obiektu, który j¹ wywo³a³. Dostêp do tego wskaYnika uzyskuje siê dziêki s³owu (wskaYnikowi) this, który jest niejawnym parametrem wszystkich funkcji wchodz¹cych w sk³ad obiektu (aplikacji). Je¿eli w pewnej, wydzielonej czêoci aplikacji, np. w jakiejo funkcji, wywo³ujemy funkcjê obs³ugi zdarzenia, której argumentem jest z regu³y wskaYnik TObject *Sender, nale¿y wówczas jawnie uzyskaæ do niego dostêp. Z regu³y robimy to korzystaj¹c w³aonie ze wskaYnika this |
Wydruk 6.4. Kod modu³u Unit07.cpp aplikacji wykorzystuj¹cej listê akcji TActionList w celu zorganizowania pracy g³ównego menu oraz ca³ego programu.
#include <vcl.h>
#pragma hdrstop
#include "Unit07.h"
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
void __fastcall TForm1::FormCreate(TObject *Sender)
void __fastcall TForm1::CheckFileSave(void)
}
void __fastcall TForm1::FileNewClick(TObject *Sender)
void __fastcall TForm1::FileOpenClick(TObject *Sender)
void __fastcall TForm1::FileSaveAsClick(TObject *Sender)
void __fastcall TForm1::UndoClick(TObject *Sender)
void __fastcall TForm1::CutClick(TObject *Sender)
void __fastcall TForm1::PasteClick(TObject *Sender)
void __fastcall TForm1::CopyClick(TObject *Sender)
void __fastcall TForm1::CloseApplicationClick(TObject *Sender)
case ID_CANCEL : Abort();
};
Funkcje zdarzeniowe CutClick() PasteClick() CopyClick(), towarzysz¹ce podmenu Edycja oraz zaimplementowane w odpowiednich
przyciskach zgrupowanych w panelu ToolBar1, czyli Cut Paste Copy korzystaj¹ z metod: RichEdit1->CutToClipboard() RichEdit1->PasteFromClipboard()i RichEdit1->CopyToClipboard() Funkcje te Z apewniaj¹c
mo¿liwooæ
umo¿liwiaj¹
tak¿e usuwanie usuniêcia fragmentu tekstu,
wstawiaenie
fragmentu tekstu znajduj¹cego siê w schowku (ang. clipboard) oraz s kopiowanie
fragmentu tekstu do schowka. Mo¿liwe jest równie¿ zaznaczaenie
ca³ooci tekstu przy wykorzystaniu metody RichEdit1->SelectAll(). Aby powtórzyæ ostatnio wykonan¹ (na tekocie) operacjê,
nale¿y skorzystaæ z metody RichEdit1->HandleAllocated(), umieszczonej w funkcji obs³ugi zdarzenia UndoClick()
Æwiczenie 6.5.
Za³ó¿my na dysku oddzielny
katalog, i
nazwijemy
go \Projekt08.
Zaprojektujmy formularz w ten sposób, aby sk³ada³ siê z dwóch komponentów TButton oraz po jednym TTimer i TApplicationEvents, tak jak pokazuje to rys. 6.14.
Rys. 6.14. Komponenty formularza projektu Projekt08.bpr |
|
Zaznaczaj¹c komponent Timer1, w karcie zdarzeñ inspektora obiektów jego cechê OnTimer ustalmy jako TimerOnTimer. W wyniku tego dzia³ania Zapewni
nam to, ¿e Timer generowaæ bêdzie zdarzenia w mniej wiêcej równych
odstêpach czasu okreolonych przez jego w³aociwooæ Interval. Treoæ funkcji obs³ugi zdarzenia TimerOnTimer()
wype³nijmy kodem przedstawionym na wydruku 6.5. Zastosujemy owaliomy
proste funkcje trygonometryczne sin() oraz cos() w celu
opisania toru ruchu przycisku Button1 oraz ca³ego formularza.
Poniewa¿ funkcje trygonometryczne w wyniku nie zawsze zwracaj¹ liczbê ca³kowit¹
(w³aociwooci Top oraz Left musz¹ byæ typu int), dlatego rezultat wykonania tych
funkcji zostanie zaokr¹glony
poprzez funkcjê floor(). Funkcje te wymagaj¹ w³¹czenia biblioteki math.h. M_PI jest predefiniowan¹ sta³¹ reprezentuj¹c¹ liczbê p
W funkcji obs³ugi zdarzenia ApplicationEventsActivate() uaktywnijamy dzia³anie
Timera korzystaj¹c z jego w³aociwooci Enabled. Aby dostaæ siê do wnêtrza tej
funkcji zaznaczamy komponent ApplicationEvents1 i w karcie zdarzeñ inspektora obiektów jego zdarzeniu OnActivate przypiszmy ujemy ApplicationEventsActivate. Naciskaj¹c Enter (lub klikaj¹c dwa razy) dostaniemy jemy
siê do wnêtrza funkcji odpowiedniego zdarzenia.
W analogiczny sposób zaprojektujemy
funkcjê obs³ugi zdarzenia ApplicationEventsDeactivate()
W funkcji obs³ugi zdarzenia Button1Click() zainicjujemy owaliomy
generator liczb losowych Randomize(), nastêpnie korzystaj¹c z
funkcji int
random(int num) losuj¹cej liczby z przedzia³u <0; num-1> dokonamy ujemy losowego
wyboru komunikatu przypisanego odpowiedniemu indeksowi tablicy text
Wydruk 6.5. Kompletny kod modu³u Unit08.cpp projektu Projekt08.bpr
#include <vcl.h>
#include <math.h>
#pragma hdrstop
#include "Unit08.h"
#pragma package(smart_init)
#pragma resource "*.dfm"
double counter = 0; // licznik
AnsiString text[10];
TForm1 *Form1;
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
void __fastcall TForm1::TimerOnTimer(TObject *Sender)
void __fastcall TForm1::FormCreate(TObject *Sender)
void __fastcall TForm1::Button2Click(TObject *Sender)
void __fastcall TForm1::Button1Click(TObject *Sender)
void __fastcall TForm1::ApplicationEventsActivate(TObject *Sender)
void __fastcall TForm1::ApplicationEventsDeactivate(TObject *Sender)
Dzia³anie programu sprowadza siê do prostej
animacji jednego z przycisków oraz ca³ego formularza. Aby wstrzymaæ dzia³anie
aplikacji nale¿y klikn¹æ jakieo miejsce gdzieo na
pulpicie poza obszarem formularza.
Æwiczenie 6.6.
Zmodyfikuj przedstawiony na wydruku 6.5 program, tak aby mo¿na by³o wykorzystaæ inne zdarzenia udostêpniane przez TApplicationEvents. Po¿yteczn¹ oci¹gawkê mo¿na znaleYæ w katalogu instalacyjnym Buildera \Examples\AppEvents\.
Karta Win 3.1 udostêpnia listê komponentów stosowanych w starszych, 16-bitowych wersjach C++Buildera. Nie jest zalecane u¿ywanie komponentów posiadaj¹cych swoje odpowiedniki np. w obecnych kartach Win32[EK81] czy Data Controls, co zosta³o zaznaczone w poni¿szym zestawieniu.
Tabela 6.6. Komponenty karty Win 3.1
Ikona |
Typ |
Znaczenie |
|
TTabSet |
Odpowiada komponentowi TTabControl z karty Win32 |
|
TOutLine |
Odpowiada komponentowi TTreeView z karty Win32 |
|
TTabbedNoteBook |
Odpowiednik TPageControl z karty Win32 |
|
TNoteBook |
Odpowiednik TPageControl |
|
THeader |
Odpowiada komponentowi THeaderControl z karty Win32 |
|
TFileListBox |
Komponent daj¹cy mo¿liwooæ wyowietlenia listy plików wskazanego katalogu. |
|
TDirectoryListBox |
Element |
|
TDriveComboBox |
Komponent
pozwalaj¹cy dokonaæ |
|
TFilterComboBox |
Komponent,
który |
|
DBLookupList |
Odpowiada komponentowi TDBLookupListBox z karty Data Controls dostêpnej w wersji Enterprise C++Buildera 5. |
|
DBLLookupCombo |
Odpowiada komponentowi TDBLookupComboBox z karty Data Controls dostêpnej w wersji Enterprise C++Buildera 5. |
Komponenty karty
Win 3.1 mimo no,
i¿ pochodz¹ ze starszych wersji C++Buildera s¹ w dalszym
ci¹gu czêsto u¿ywane. Chodzi g³ównie o komponenty u³atwiaj¹ce bardzo szybie
wczytanie wybranego pliku. Obiekty obs³uguj¹ce te zdarzenia maj¹ jeszcze jedn¹
powa¿n¹ zaletê, mianowicie wczytywany plik mo¿na natychmiast poddaæ edycji.
Zilustrujemy to na przyk³adzie prostego æwiczenia.
Æwiczenie 6.7.
Zaprojektujmy formularz sk³adaj¹cy siê z pojedynczych komponentów TDirectoryListBox TFileListBox TDriveComboBox TFilterComboBox TEdit TMemo oraz TButton tak jak pokazuje to rys. 6.15. Aby
obiekty s³u¿¹ce do wyboru napêdu, wyboru katalogów, przegl¹dania katalogów
"widzia³y siê nawzajem" nale¿y ich cechy odpowiednio ze sob¹
powi¹zaæ. Mo¿na to zrobiæ korzystaj¹c z inspektora obiektów lub
co jest bardziej przejrzyste dokonuj¹c odpowiednich
przypisañ dokonaæ w funkcji FormCreate(), pokazanych na wydruku 6.6.
W³aociwooci FileList obiektu DirectoryListBox1 przypiszmy FileListBox1
W³aociwooci DirList obiektu DriveComboBox1 przypiszmy DirectoryListBox1
W³aociwooæ FileEdit komponentu FileListBox1 ustalmy jako Edit1
W³aociwooæ Filter obiektu FilterComboBox1 ustalmy przyk³adowo tak, jak pokazuje to poni¿szy wydruk.
Klikaj¹c dwukrotnie w
obszar FileListBox1 dostaniemy siê do wnêtrza funkcji obs³ugi zdarzenia FileListBox1Change(). Wystarczy wype³niæ j¹ znanym nam ju¿ kodem.
Cechê Mask komponentu FileListBox1 ustalmy jako FilterComboBox1->Mask. Czynnooæ tê wykonamy w funkcji obs³ugi zdarzenia FilterComboBox1Change()
Rys. 6.15. Dzia³aj¹cy Projekt09.bpr |
|
Wydruk 6.6. Kompletny kod modu³u Unit09.cpp projektu Projekt09.bpr
#include <vcl.h>
#pragma hdrstop
#include "Unit09.h"
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
void __fastcall TForm1::FormCreate(TObject *Sender)
void __fastcall TForm1::FilterComboBox1Change(TObject *Sender)
void __fastcall TForm1::FileListBox1Change(TObject *Sender)
catch(...)
void __fastcall TForm1::Button1Click(TObject *Sender)
Karta Samples zawiera 9 przyk³adowych komponentów. Ich kody Yród³owe znajduj¹ siê w katalogu instalacyjnym Buildera \EXAMPLES\CONTROLS\SOURCE. W momencie w³¹czenia tych komponentów do formularza, ich pliki nag³ówkowe zostan¹ do³¹czone dyrektyw¹ #pragma link, która informuje konsolidator o potrzebie do³¹czenia danego zbioru do pliku wykonawczego programu.
Tabela 6.7. Komponenty karty Samples
Ikona |
Typ |
Znaczenie |
|
TPie |
Element s³u¿¹cy
do przedstawiania okrêgu lub wycinka |
|
TTrayIcon |
Komponent, który |
|
TPerformanceGraph |
Element s³u¿¹cy do przedstawienia grafiki. Kod Yród³owy komponentu znajduje siê w plikach PERFGRAP.*. |
|
TCSpinButton |
Komponent
|
|
TCSpinEdit |
Element |
|
TCColorGrid |
Komponent umo¿liwiaj¹cy dokonanie wyboru koloru. Jego kod Yród³owy znajduje siê w plikach CGRID.* |
|
TCGauge |
Komponent
przedstawiaj¹cy wskaYnik postêpu. Dziêki w³aociwooci Kind mo¿na go przedstawiæ w
postaci paska, liczby, ko³a lub wycinka |
|
TCDirectoryOutLine |
Wyowietla drzewo katalogów znajduj¹cych siê na dysku. Kod Yród³owy komponentu znajduje siê w plikach cdiroutl.* |
|
TCCalendar |
Komponent wyowietlaj¹cy aktualn¹ datê w postaci uproszczonego kalendarza. Jego kod Yród³owy znajduje siê w pliku CCALENDR.*. |
Jako przyk³ad wykorzystania niektórych komponentów z kart Samples oraz Standard stworzymy prost¹ aplikacjê, przy pomocy której mo¿liwym bêdzie animacja ikon. Zmieniaj¹ce siê ikony bêd¹ wyowietlane na dolnym pasku zadañ w prawym rogu monitora tu¿ obok zegara.
Æwiczenie 6.8.
Zaprojektujmy formularz sk³adaj¹cy siê z pojedynczych komponentów TCSpinEdit TTrayIcon TImageList TButton oraz dwóch komponentów typu TCheckBox tak jak pokazuje to rysunek. 6.16.
Rys. 6.16. Komponenty formularza projektu Projekt10.bpr |
|
Korzystaj¹c z inspektora obiektów w³aociwooæ Icons komponentu TrayIcon1
zmieñmy na ImageList1. Tym samym spowodujemy, ¿e ikony wczytane do komponentu ImageList1 bêd¹ "widziane" przez TrayIcon1. W podobny sposób (¿eby zbytnio nie komplikowaæ dalszych rozwa¿añ) w³aociwoociom PopupMenuOn oraz RestoreOn przypiszmy imNone
Cechy Caption komponentów CheckBox1 oraz CheckBox2 zmieñmy odpowiednio na Animacja oraz Poka¿ ikonê
Cechy Increment MinValue oraz MaxValue komponentu CSpinEdit1 ustalmy w
sposób pokazany w funkcji FormCreate() na wydruku 6.7.
We wnêtrzu tej samej funkcji cechê Visible komponentu TrayIcon1 uzale¿nimy od aktualnego stanu komponentu CheckBox2 reprezentowanego przez w³aociwooæ
Checked
W³aociwooæ Animate komponentu TrayIcon1 uzale¿nimy od stanu cechy Checked
komponentu CheckBox1
W³aociwooci AnimateInterval komponentu TrayIcon1 przypiszmy wartooæ cechy Value komponentu CSpinEdit1
Kompletny kod g³ównego modu³u naszej aplikacji powinien wygl¹daæ tak jak przedstawiono to na wydruku 6.7.
Wydruk 6.7. Kod modu³u Unit10.cpp aplikacji Projekt10.bpr wykonuj¹cej prost¹ animacjê ikon.
#include <vcl.h>
#pragma hdrstop
#include "Unit10.h"
#pragma package(smart_init)
#pragma link "CSPIN"
#pragma link "Trayicon"
#pragma resource "*.dfm"
TForm1 *Form1;
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
void __fastcall TForm1::FormCreate(TObject *Sender)
void __fastcall TForm1::CheckBox1Click(TObject *Sender)
void __fastcall TForm1::CheckBox2Click(TObject *Sender)
void __fastcall TForm1::CSpinEdit1Change(TObject *Sender)
void __fastcall TForm1::Button1Click(TObject *Sender)
Przedstawiony algorytm ka¿dy na w³asny u¿ytek mo¿e wzbogaciæ o szereg innych elementów. Zagl¹daj¹c do kodów Yród³owych poszczególnych komponentów karty Samples mo¿emy samodzielnie odszyfrowaæ jeszcze wiele ich mo¿liwooci.
Æwiczenie 6.9.
Zaprojektujemy aplikacjê wykorzystuj¹c¹ komponent TCCalendar. Dodatkowo
pos³u¿ymy siê komponentami TBitBtn z karty Additional oraz TGroupBox z karty Standard. Wykorzystamy te¿ dobrze nam ju¿ znany przycisk TButton
Na formularzu umieszczamy komponent
Calendar1 reprezentuj¹cy klasê TCCalendar. W inspektorze obiektów
jego cechê BorderStyle zmieñmy na bsSingle. Klikaj¹c nañ dwukrotnie
dostajemy siê do funkcji obs³ugi zdarzenia Calendar1Change().
Korzystaj¹c z metody DateToStr() w³aociwooci Caption naszego kalendarza e przypiszmy
aktualn¹ datê Calendar1->CalendarDate
Rozmieoæmy na formularzu dwa komponenty GroupBox1oraz GroupBox2 reprezentuj¹ce klasê TGroupBox. Ich cechy Caption zmieñmy odpowiednio na &Cofnij oraz &Dalej
W obszarze wymienionych komponentów rozmieszczamy po dwa obiekty TBitBtn. Mo¿emy uprzednio przy pomocy edytora rysunków przygotowaæ odpowiednie rysunki i korzystaj¹c z w³aociwooci Glyph umieociæ je na przyciskach, tak jak pokazuje to rys. 6.17.
Korzystamy z metod PrevYear() PrevMonth() NextYear() oraz NextMonth() w celu uzupe³nienia naszego kalendarza w funkcje obs³ugi odpowiednich zdarzeñ polegaj¹cych na wybraniu kolejnego roku lub miesi¹ca. Kompletny kod naszej aplikacji znajduje siê na wydruku 6.8.
Rys. 6.17. Dzia³aj¹cy kalendarz |
|
Wydruk 6.8. Kod modu³u Unit11.cpp kalendarza: Projekt11.bpr
#include <vcl.h>
#pragma hdrstop
#include "Unit11.h"
#pragma package(smart_init)
#pragma link "CCALENDR"
#pragma resource "*.dfm"
TForm1 *Form1;
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
void __fastcall TForm1::FormCreate(TObject *Sender)
void __fastcall TForm1::Calendar1Change(TObject *Sender)
void __fastcall TForm1::BitBtn1Click(TObject *Sender)
void __fastcall TForm1::BitBtn2Click(TObject *Sender)
void __fastcall TForm1::BitBtn4Click(TObject *Sender)
void __fastcall TForm1::BitBtn3Click(TObject *Sender)
void __fastcall TForm1::Button1Click(TObject *Sender)
Wykonany w³asnymi si³ami kalendarz mo¿e wzbogaciæ nasze aplikacje o opcje pozwalaj¹ce na proste kontrolowanie aktualnej daty bez potrzeby wnikania w skomplikowane zasoby systemu Windows. Oczywiocie taki kalendarz w ka¿dej chwili mo¿emy ukryæ. Wystarczy jego cechê Visible ustaliæ jako FALSE, co wcale nie przeszkadza, aby aktualna data nie by³a wyowietlana w jakimo miejscu aplikacji.
Komponenty karty ActiveX nie wchodz¹ w sk³ad biblioteki VCL. S¹ to przyk³adowe obiekty ActiveX, zaprojektowane w ten sposób, by mo¿na by³o natychmiast skorzystaæ z ich us³ug.
Tabela 6.8. Niektóre komponenty karty ActiveX
Ikona |
Typ |
Znaczenie |
|
TChartfx |
Obiekt ActiveX s³u¿¹cy do tworzenia wykresów. |
|
TVSSpell |
Visual Speller Control Properties. Komponent pe³ni¹cy rolê tzw. spell-chackera |
|
TF1Book |
Obiekt posiadaj¹cy cechy arkusza kalkulacyjnego. |
|
TVtChart |
Komponent s³u¿¹cy to tworzenia wykresów. |
Æwiczenie 6.10.
Jako przyk³ad wykorzystania w naszych aplikacjach niektórych komponentów karty
ActiveX poka¿emy, jak w bardzo prosty sposób mo¿na skorzystaæ z reprezentanta klasy
TF1Book
Umieoæmy na formularzu komponent F1Book1. Klikaj¹c dwukrotnie w jego obszar ze
mo¿emy zapoznaæ siê z jego w³aociwoociami, które w wiêkszooci s¹ zdublowane w
analogicznej karcie inspektora obiektów.
Rys. 6.18. W³aociwooci VCI Formula One Workbook |
|
Po skompilowaniu i uruchomieniu aplikacji dwukrotnie klikaj¹c prawym klawiszem myszki dostaniemy siê do Formula One Workbook Designer, który jest odpowiednikiem prostego arkusza kalkulacyjnego. Jego obszar podzielony jest na komórki, których wspó³rzêdne okreolone s¹ w sposób typowy dla arkuszy kalkulacyjnych: wiersze (ang. rows) i kolumny (ang. columns). Korzystaj¹c z menu File|Read mo¿emy wczytaæ dane zawarte w plikach tekstowych, typowe dla formatu Excela, czyli *.xls lub w formacie *.vts, który jest preferowanym formatem Workbooka. Dane w postaci liczb mo¿emy te¿ wpisywaæ samodzielnie. Równie¿ zapis danych do pliku nie powinien przedstawiaæ ¿adnych problemów.
Rys. 6.19. Formula One Workbook Designer |
|
Je¿eli zechcemy graficznie zobrazowaæ nasze dane, nale¿y najpierw je zaznaczyæ albo przy pomocy myszki, albo korzystaj¹c z kombinacji klawiszy Shift + strza³ka (kursor).
Wybieramy ostatni przycisk z podpowiedzi¹ Chart (diagram, wykres) i "ci¹gniemy" myszk¹ na wolnym obszarze arkusza. W ten sposób mo¿emy uaktywniæ kreatora wykresów Chart Wizard. Zawiera on bogaty zbiór ró¿nego rodzaju diagramów i wykresów. Zak³adki Gallery Style Layout oraz Axes u³atwiaj¹ optymalny dobór parametrów wykresu oraz dokonania jego opisu.
Je¿eli dokonamy ju¿ wyboru najbardziej odpowiadaj¹cych nam opcji, koñczymy przyciskiem Finish
Rys. 6.20. Kreator wykresów |
|
Koñcowy wynik mo¿emy zobaczyæ w postaci podobnej do tej przedstawionej na rys.
Rys. 6.21. Wykres umieszczony na arkuszu kalkulacyjnym |
|
Wykorzystuj¹c komponenty karty Internet mo¿na w aplikacjach umieszczaæ opcje pozwalaj¹ce na korzystanie z sieci Internet oraz protoko³u TCP/IP.
Tabela 6.9. Podstawowe komponenty karty Internet
Ikona |
Typ |
Znaczenie |
|
TClientSocket |
Komponent u³atwiaj¹cy po³¹czenie z innym komputerem w sieci. |
|
TServerSocket |
Komponent odpowiadaj¹cy na ¿¹dania innych komputerów w sieci. |
|
TCppWebBrowser |
Komponent
|
|
TWebDispatcher |
Komponent,
przy pomocy którego nastêpuje |
|
TPageProducer |
Komponent
|
|
TQueryTableProducer |
Komponent
tworz¹cy tablice HTML na podstawie |
|
TDataSetTableProducer |
Komponent
|
Karta Servers zawiera 30 komponentów bêd¹cych swego rodzaju wizualizacj¹ aktualnie dostêpnych serwerów COM dokonan¹ na potrzeby biblioteki VCL. Wszystkie wywodz¹ siê z obiektu TOleServer. Przy ich pomocy mo¿emy automatycznie po³¹czyæ siê z wybranym serwerem COM.
Rys. 6.22. Karta Servers |
|
Dok³adne omówienie wszystkich komponentów karty Servers wraz z ich w³aociwoociami i metodami, z których korzystaj¹, a tym samym budowy serwerów COM znacznie wykracza poza ramy naszych æwiczeñ. Niemniej jednak mo¿emy chocia¿by jakoociowo zapoznaæ siê z podstawowymi w³asnoociami wybranych obiektów. Prawdopodobnie nie ma woród nas nikogo, kto by nie mia³ do czynienia z narzêdziami pakietu Office. Do najbardziej podstawowych aplikacji tego pakietu nale¿y oczywiocie zaliczyæ Worda, Excela oraz Power Pointa. Spróbujmy zatem, korzystaj¹c z bardzo prostych funkcji po³¹czyæ siê z wymienionymi aplikacjami.
Tabela 6.10. Podstawowe komponenty karty Servers s³u¿¹ce do po³¹czenia z narzêdziami pakietu Office
Ikona |
Typ |
Znaczenie |
|
TPowerPointApplication |
Umo¿liwia po³¹czenie z aplikacjami Power Point. Komponent niewidzialny. Jego kod Yród³owy znajduje siê w plikach PowerPoint_97_SRVR.*. znajduj¹cych siê w katalogach \Include\VCL\ oraz \Source\Comservers\Office97\ |
|
TWordApplication |
Umo¿liwia po³¹czenie z aplikacjami Worda. Komponent niewidzialny. Jego kod Yród³owy znajduje siê w plikach Word_97_SRVR.*. znajduj¹cych siê w katalogach \Include\VCL\ oraz \Source\Comservers\Office97\ |
|
TExcelApplication |
Umo¿liwia po³¹czenie z aplikacjami Excela. Komponent niewidzialny. Jego kod Yród³owy znajduje siê w plikach Excel_97_SRVR.* znajduj¹cych siê w katalogach \Include\VCL\ oraz \Source\Comservers\Office97\ |
Æwiczenie 6.11.
Zaprojektujemy formularz sk³adaj¹cy siê z trzech komponentów typu TGroupBox. W ich
obszarach umieszczamy po dwa przyciski TButton, które bêd¹ odpowiadaæ za
nawi¹zanie po³¹czenia z wybranym serwerem COM oraz jego dezaktywacjê. Dodatkowo
na formularzu umieszczamy po jednym komponencie TPowerPointApplication
TWordApplication oraz TExcelApplication podobnie jak na rysunku 6.23.
Rys. 6.23. Aplikacja wykorzystuj¹ca przyk³adowe komponenty karty Servers w celu dokonania po³¹czeñ z wybranymi serwerami COM |
|
W najprostszym przypadku ustanowienie po³¹czenia z wybranym serwerem
dokonujemy korzystaj¹c z metody Connect(), której odpowiednie wywo³ania zosta³y umieszczone w funkcji FormCreate()
W celu wizualizacji po³¹czenia przewa¿nie korzystamy z w³aociwooci Visible poszczególnych obiektów. Pewnym wyj¹tkiem mog¹ byæ aplikacje Excela, gdzie niekiedy wygodniej jest skorzystaæ z metody Set_Visible() wywo³ywanej z odpowiednimi parametrami.
Aby bezpiecznie dezaktywowaæ po³¹czenie korzystamy z metody Disconnect()
Wydruk 6.9. Kod modu³u Unit12.cpp aplikacji realizuj¹cej po³¹czenia z wybranymi serwerami COM.
#include <vcl.h>
#pragma hdrstop
#include "Unit12.h"
#pragma package(smart_init)
#pragma link "PowerPoint_97_SRVR"
#pragma link "Word_97_SRVR"
#pragma link "Excel_97_SRVR"
#pragma resource "*.dfm"
TForm1 *Form1;
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
void __fastcall TForm1::FormCreate(TObject *Sender)
void __fastcall TForm1::Button1Click(TObject *Sender)
void __fastcall TForm1::Button2Click(TObject *Sender)
void __fastcall TForm1::Button4Click(TObject *Sender)
void __fastcall TForm1::Button5Click(TObject *Sender)
void __fastcall TForm1::Button6Click(TObject *Sender)
void __fastcall TForm1::Button7Click(TObject *Sender)
void __fastcall TForm1::Button3Click(TObject *Sender)
|
Metoda Disconnect() wchodzi w zakres innej metody BeforeDestruction(), której wywo³ywanie w sposób jawny nie jest jednak zalecane. |
Korzystaj¹c z prostego algorytmu przedstawionego na wydruku 6. 9 mo¿emy bez problemu z poziomu dzia³aj¹cej aplikacji napisanej w Borland C++Builderze 5 uruchomiæ wymienione narzêdzia pakietu Office. Bêd¹ one pracowa³y w taki sam sposób jakby by³y uruchamiane w sposób tradycyjny, tzn. bezpoorednio z pulpitu. Pokazana idea komunikacji COM pozwala te¿ na wielokrotne uruchamianie i dezaktywacjê wybranego po³¹czenia.
W trakcie niniejszego rozdzia³u zapoznaliomy siê z podstawowymi, dostêpnymi w C++Builderze 5 elementami biblioteki VCL. Wykonuj¹c parê prostych æwiczeñ nauczyliomy siê pos³ugiwaæ w³aociwoociami, zdarzeniami oraz metodami ró¿nych komponentów. Przyk³adowe, kompletne wydruki stosowanych algorytmów pomog¹ nam zrozumieæ, jak z pokazanych komponentów mo¿emy skorzystaæ w praktyce.
Wszystkie przedstawione w poprzednich rozdzia³ach przyk³adowe aplikacje w ka¿dym szczególe konstruowaliomy samodzielnie nabieraj¹c wprawy w manipulowaniu komponentami biblioteki VCL. Nale¿y jednak pamiêtaæ, ¿e istnieje du¿o prostszy (ale mniej kszta³c¹cy) sposób zaprojektowania formularza. Mo¿na w tym celu skorzystaæ z menu File|New|Projects. W ten sposób dostaniemy siê do zak³adki z gotowymi szablonami formularza (rys. 7.1).
Rys. 7.1. Dostêpne, przyk³adowe projekty ró¿nych formularzy |
|
Wybieraj¹c przyk³adowy projekt aplikacji jednodokumentowej SDI Application (ang. Single Document Interface) otrzymujemy gotowy do u¿ycia i ewentualnie dalszego uzupe³niania formularz. Widzimy na nim gotowe komponenty TSaveDialog TOpenDialog TImageList TActionList TMainMenu TStatusBar. Wszystkie maj¹ ju¿ odpowiednio wykonane przypisania. Aplikacja taka, przynajmniej w swej warstwie edycyjnej jest praktycznie gotowa do u¿ycia.
Rys. 7.2. Formularz aplikacji jednodokumentowej |
|
Aplikacje wielodokumentowe MDI Application (ang. Multi Document Interface) s³u¿¹ do zarz¹dzania zdarzeniami zachodz¹cymi w kilku oknach jednoczeonie. Podstawow¹ rzecz¹, jaka odró¿nia je od aplikacji SDI, jest styl stosowanego formularza. O ile w przypadku aplikacji SDI styl formularza reprezentowany przez w³aociwooæ FormStyle jest typu fsNormal (zob. karta w³aociwooci inspektora obiektów), to w przypadku aplikacji MDI formularz posiadaæ bêdzie styl fsMDIForm. Wszystkie jego okna potomne reprezentowane bêd¹ przez formularze fsMDIChild. Centraln¹ czêoæ formularza widocznego na rysunku 7.3 stanowi tzw. okno klienta (ang. client window).
Rys. 7.3. Formularz aplikacji MDI |
|
Wszystkie okna
potomne (ang. child window) bêd¹c
umieszczane w oknie klienta, s¹ ca³kowicie mu podporz¹dkowane, tak jak pokazuje
to rysunek 7.4
Rys. 7.4. Przyk³ad aplikacji korzystaj¹cej z wielu dokumentów wyowietlanych w oknach potomnych |
|
Okna takie mo¿emy dowolnie konfigurowaæ korzystaj¹c z przycisków znajduj¹cych siê na pasku menu lub bezpoorednio z g³ównego menu (menu systemowego).
Zachêcam Czytelników do
samodzielnego przetestowania w³aociwooci przedstawionych formularzy, a tak¿e do
zaznajomienia siê z ich kodami Yród³owymi. Bêdzie to ciekawe i
kszta³c¹ce zajêcie.dodatkowo ciekawym i kszta³c¹cym zajêciem
niew¹tpliwie by³oby w ramach samodzielnego æwiczenia zaznajomienie siê z kodami
Yród³owymi tych formularzy. Równie¿ ka¿da próba uzupe³nienia formularzy
ich o nowe, w³asne elementy pozwoli
nam w wiêkszym stopniu oswoiæ siê z tego typu aplikacjami.
Celem tego
krótkiego, koñcz¹cego ju¿ ksi¹¿kê, rozdzia³u by³o zaprezentowanie gotowych
do u¿ycia projektów formularzy udostêpnianych nam przez C++Buildera. Dodatkowo
ka¿dy z Czytelników móg³ mo¿e siê
zapoznaæ z szablonem aplikacji klienta do Windows 2000 lub z technik¹ tworzenia
logo w aplikacjach. Zamieszczone w menu File|New|Projects
przyk³ady prawie ju¿ gotowych programów nale¿y
jednak traktowaæ jako swego rodzaju pomoc metodyczn¹. Najwiêkszym bowiem
b³êdem, jaki mo¿e zrobiæ osoba zaczynaj¹ca dopiero tworzyæ w C++Builderze jest
bezkrytyczne, ju¿ na wstêpie siêgniêcie do
omówionych przyk³adów. Pokazane przyk³adowe aplikacje mog¹ byæ nam bardzo
pomocne pod jednym tylko warunkiem, jakim jest mianowicie,
je¿eli bêdziemy mieli owiadomooæ, ¿e coo podobnego jesteomy w
stanie stworzyæ równie¿ samodzielnie.
W przypadku bardzo rozbudowanych pojedynczych aplikacji lub grup aplikacji zalecane jest do³¹czanie tych bibliotek g³ównie dla bezpieczeñstwa funkcjonowania systemu Windows.
PAGE \# "'Strona: '#'
'" [EK1] Zmieni³abym na: "C++Builder 5, jeden z najnowszych produktów firmy
Borland/Imprise, reprezentuje niezwyk³e mo¿liwooci programistyczne.
PAGE \# "'Strona: '#'
'" [EK2] Czy chodzi o: "niezwykle du¿y wybór metod programowania oferowany
[...]"?
PAGE \# "'Strona: '#'
'" [EK3] Czy to poprawne sformu³owanie?
PAGE \# "'Strona: '#'
'" [EK4] Czy to prawid³owe okreolenie?
PAGE \# "'Strona: '#'
'" [EK5]
PAGE \# "'Strona: '#'
'" [EK6] Bardzo nieczytelna charakterystyka jêzyka C++Builder Enterprise (bo
chyba rzecz dotyczy jêzyka
programowania?). W koñcówce tego akapitu ju¿ zupe³nie nie wiadomo o co chodzi.
Co to jest TeamSource i czy to TeamSource stwarza mo¿liwooci grupowania
projektów (jakich projektów), czy te¿ takie mo¿liwooci ma C++Builder
Enterprise?
PAGE \# "'Strona: '#'
'" [EK7] Komponenty biznesowe - có¿ to takiego?
PAGE \# "'Strona: '#'
'" [EK8]
PAGE \# "'Strona: '#'
'" [EK9] "wizualnego budowania" czy "budowania wizualnych aplikacji"?
PAGE \# "'Strona: '#'
'" [EK10] Mo¿e "elementów, czêoci, sk³adników"? S³owo "komponent" ci¹gle siê
tutaj powtarza.
PAGE \# "'Strona: '#'
'" [EK11] Czy chodzi o interfejs programu Win32 API? "Programista" to osoba
zajmuj¹ca siê programowaniem, tworzeniem programu, tymczasem mam wra¿enie, ¿e
Autor u¿ywa tego s³owa w znaczeniu "program, programowanie".
PAGE \# "'Strona: '#'
'" [EK12] Czy to prawid³owy zapis? Czy mo¿e: Win.3.2?
PAGE \# "'Strona: '#'
'" [EK13] Jak siê ma OLE Automation do C++Builder Standard?
PAGE \# "'Strona: '#'
'" [EK14] Mo¿e raczej umiejscawianie lub umieszczanie.
PAGE \# "'Strona: '#'
'" [EK15] Oznaczy³am kursyw¹.
PAGE \# "'Strona: '#'
'" [EK16] Zdaje siê, ¿e przyjê³o siê t³umaczyæ te s³owa jako "przeci¹gnij i
upuoæ" i z tego co wiem, te¿ jest to dos³owne t³umaczenie.
PAGE \# "'Strona: '#'
'" [EK17] Czy to poprawne sformu³owanie?
PAGE \# "'Strona: '#'
'" [EK18] Co to jest IDE?
PAGE \# "'Strona: '#'
'" [EK19] Czy to poprawne sformu³owanie?
PAGE \# "'Strona: '#'
'" [EK20] Czy to poprawne okreolenie?
PAGE \# "'Strona: '#'
'" [EK21] Czy chodzi o "Dopasowanie i wyrównanie fragmentu zaznaczonego
wczeoniejszym poleceniem."?
PAGE \# "'Strona: '#'
'" [EK22]
Lista pu³apek pomocnych w oledzeniu programu?
Czy debuggera u¿ywa siê do wyowietlenia pu³apek, czy do oledzenia programu?
PAGE \# "'Strona: '#'
'" [EK23] "i dostosowanie pliku do opisu projektu"?
PAGE \# "'Strona: '#'
'" [EK24] Czy chodzi o: "To polecenie spowoduje po³¹czenie kodów Yród³owych
wszystkich tych modu³ów projektu, w których dokonano zmian od czasu ostatniej kompilacji."
PAGE \# "'Strona: '#'
'" [EK25] Czy to prawid³owe okreolenie?
PAGE \# "'Strona: '#'
'" [EK26] Czy chodzi o: "Podanie informacji na temat ostatnio skompilowanego
projektu (chodzi o liczbê linii, rozmiar kodu, rozmiar pliku wykonywalnego itp.)
PAGE \# "'Strona: '#'
'" [EK27]
PAGE \# "'Strona: '#'
'" [EK28]
PAGE \# "'Strona: '#'
'" [EK29] Czy mo¿e lepiej "Wywo³anie zak³adki New Component powoduje utworzenie nowego elementu formularza".
PAGE \# "'Strona: '#'
'" [EK30] Czy to zdanie odnosi siê tylko do polecenia "Windows SDK", czy te¿ do
wszystkich trzech wymienionych poleceñ?
PAGE \# "'Strona: '#'
'" [EK31] Które polecenia?
PAGE \# "'Strona: '#'
'" [EK32] Czy nie jest to zbyt sk¹pa charakterystyka polecenia "About..."?
PAGE \# "'Strona: '#'
'" [EK33] Edytowaæ metody?
PAGE \# "'Strona: '#'
'" [EK34]
PAGE \# "'Strona: '#'
'" [EK35] Czy to poprawne sformu³owanie?
PAGE \# "'Strona: '#'
'" [EK36] Czy Win.3.2?
PAGE \# "'Strona: '#'
'" [EK37] Interfejs programisty czy interfejs programowy?
PAGE \# "'Strona: '#'
'" [EK38] Czy: kompilowane?
PAGE \# "'Strona: '#'
'" [EK39] Czy: kompilacji?
PAGE \# "'Strona: '#'
'" [EK40] Czy: wykonywalnym?
PAGE \# "'Strona: '#'
'" [EK41] Czy to prawid³owa nazwa?
PAGE \# "'Strona: '#'
'" [EK42] Czy: wykonywalnych?
PAGE \# "'Strona: '#'
'" [EK43] Która? Use dynamic RTL?
PAGE \# "'Strona: '#'
'" [EK44] Odnaczona, tzn. nieaktywna, a jeoli tak, to nie bêdziemy jawnie
w³¹czaæ dynamicznych bibliotek do naszych programów.
PAGE \# "'Strona: '#'
'" [EK45] Do czego odnosi siê zaimek "je"? Do bibliotek?
PAGE \# "'Strona: '#'
'" [EK46] Czy to poprawne okreolenie?
PAGE \# "'Strona: '#'
'" [EK47] Czy to poprawne okreolenie?
PAGE \# "'Strona: '#'
'" [EK48] Czy to poprawne sformu³owanie?
PAGE \# "'Strona: '#'
'" [EK49] Niestety, nie wiem jaki jest prawid³owy zapis skrótu BCB5.
PAGE \# "'Strona: '#'
'" [EK50]
PAGE \# "'Strona: '#'
'" [EK51] Czy chodzi o rezultat wykonania kodu przy zastosowaniu innych
operatorów relacyjnych?
PAGE \# "'Strona: '#'
'" [EK52] Czy to poprawne okreolenie?
PAGE \# "'Strona: '#'
'" [EK53] Czy chodzi o to, ¿e "W czêoci pocz¹tkowej wykonywania instrukcji,
zmiennej steruj¹cej zostanie nadana pewna wartooæ."?
PAGE \# "'Strona: '#'
'" [EK54] Danego cyklu czego?
PAGE \# "'Strona: '#'
'" [EK55] ? W czêoci zwiêkszania o 1?
PAGE \# "'Strona: '#'
'" [EK56] Czy okreolenie "pêtla for" jest równoznaczne z okreoleniem "instrukcja
for"?
PAGE \# "'Strona: '#'
'" [EK57]
PAGE \# "'Strona: '#'
'" [EK58]
PAGE \# "'Strona: '#'
'" [EK59] Czy chodzi o zmienn¹ i? Nie mo¿na u¿yæ s³owa "dana" w znaczeniu rzeczownikowym, a tylko
przymiotnikowym, np. dana ksi¹¿ka lub dana zmienna.
PAGE \# "'Strona: '#'
'" [EK60] Na kim? Na czym?
PAGE \# "'Strona: '#'
'" [EK61]
PAGE \# "'Strona: '#'
'" [EK62] Co nale¿y? Obiekt czy funkcja?
PAGE \# "'Strona: '#'
'" [EK63]
PAGE \# "'Strona: '#'
'" [EK64] Dostosowaæ sposób wyróznienia do s³owa "Align
PAGE \# "'Strona: '#'
'" [EK65]
PAGE \# "'Strona: '#'
'" [EK66] Od jakiej pory?
PAGE \# "'Strona: '#'
'" [EK67]
PAGE \# "'Strona: '#'
'" [EK68] Tzn. co?
PAGE \# "'Strona: '#'
'" [EK69] Ale na czym polega³o?
PAGE \# "'Strona: '#'
'" [EK70]
PAGE \# "'Strona: '#'
'" [EK71] Co? Zdarzenie?
PAGE \# "'Strona: '#'
'" [EK72] Wydaje mi siê, ¿e to s³owo trzeba jakoo wyró¿niæ, ale nie wiem jak.
PAGE \# "'Strona: '#'
'" [EK73]J.w.
PAGE \# "'Strona: '#'
'" [EK74] J.w.
PAGE \# "'Strona: '#'
'" [EK75] Przy pomocy których wywo³aliomy tê metodê?
PAGE \# "'Strona: '#'
'" [EK76] Left do prawego rogu?
PAGE \# "'Strona: '#'
'" [EK77] Czy chodzi o: "[...] komponenty, które s¹ jednoczeonie podstawowymi
elementami steruj¹cymi sysytemem Windows"?
PAGE \# "'Strona: '#'
'" [EK78] Czy to prawid³owe okreolenie?
PAGE \# "'Strona: '#'
'" [EK79]
PAGE \# "'Strona: '#'
'" [EK80] Czy jest to rysunek czy tabela?
PAGE \# "'Strona: '#'
'" [EK81] Win32 czy Win 3.2?
|