InternetovskΘ aplikace


	19. InternetovskΘ aplikace

OvladaΦe Internetu v C++ Builderu jsou umφst∞ny na strßnce Internet Palety komponent. Tyto ovladaΦe je mo₧no rozd∞lit do dvou skupin. Do prvnφ skupiny °adφme ovladaΦe ActiveX poskytnutΘ firmou NetMasters. StruΦn² popis t∞chto ovladaΦ∙ je uveden v nßsledujφcφ tabulce.

OvladaΦ	Popis
TNMDayTime	Zφskßvß datum a Φas z InternetovskΘ slu₧by datetime.
TNMEcho	Zasφlß text na Internetovskou slu₧bu echo a zφskßvß jej zp∞t.
TNMFinger	Zφskßvß informace o u₧ivatelφch ze slu₧by finger.
TNMFTP	Provßdφ p°enos soubor∙ mezi poΦφtaΦi pomocφ protokolu FTP.
TNMHTTP	Provßdφ p°enos soubor∙ pomocφ protokolu HTTP (pou₧φvßme k zφskßnφ dokumentu, kter² nemß b²t zobrazen ve WebovskΘm prohlφ₧eΦi).
TNMMsg	Zasφlß textovou zprßvu pomocφ TCP/IP.
TNMMsgServ	Zφskßvß zprßvu zaslanou ovladaΦem TNMMsg.
TNMNNTP	Zasφlß a p°ijφmß zprßvy pomocφ protokolu NNTP.
TNMPOP3	Zφskßvß zprßvy email z poÜtovnφho serveru pomocφ protokolu POP3.
TNMUUProcessor	K≤duje a dek≤duje soubory.
TNMSMTP	Zasφlß email prost°ednictvφm protokolu SMTP.
TNMStrm	Zasφlß datov² proud do sφt∞.
TNMStrmServ	Zφskßvß datov² proud zaslan² ovladaΦem TNMStrm.
TNMTime	Zφskßvß Φas z Internetu.
TNMUDP	P°enßÜφ data mezi sφt∞mi pomocφ protokolu UDP.
TPowersock	Zaobaluje Winsock API.
TNMGeneralServer	Pou₧φvßno pro obecnΘ servery TCP/IP.
THTML	Zobrazuje soubory HTML. Je to komponenta WebovskΘho prohlφ₧eΦe.
TNMURL	P°evßdφ URL na °et∞zec a naopak.

Druhß kategorie ovladaΦ∙ zahrnuje komponenty TClientSocket a TServerSocket. Tyto komponenty zpracovßvajφ sokety TCP/IP. Pomocφ komponent obou skupin lze vytvß°et kvalitnφ internetovskΘ aplikace.

Jednou z programovacφch ·loh Internetu je vytvß°enφ WebovskΘho prohlφ₧eΦe. Zßklad prohlφ₧eΦe je tvo°en komponentou HTML. Tuto komponentu umφstφme na formulß° a volßme metodu RequestDoc. Tφm je prohlφ₧eΦ vytvo°en. My ale vytvo°φme nepatrn∞ slo₧it∞jÜφ prohlφ₧eΦ. ZaΦneme v²voj novΘ aplikace. Na formulß° umφstφme komponentu Panel, zm∞nφme jejφ vlastnost Align na alTop, Height na 60 a vlastnost Caption vyprßzdnφme. Na panel (do hornφho levΘho rohu) umφstφme komponentu ComboBox. Jejφ Üφ°ku zm∞nφme na Üφ°ku panelu a vlastnost Text na nßmi zvolenΘ URL (nap°. http://www.spse.cz). Na formulß° vlo₧φme jeÜt∞ komponentu StatusBar a nastavφme jejφ vlastnost SimplePanel na true. Doprost°ed formulß°e vlo₧φme komponentu HTML a zm∞nφme jejφ vlastnost Align na alClient.

OnClick

if (ComboBox1->Text != "")

HTML1->RequestDoc(ComboBox1->Text);

OnKeyPress

if (Key == VK_RETURN) {

Key = 0;

if (ComboBox1->Text == "") return;

ComboBox1->Items->Insert(0, ComboBox1->Text);

ComboBox1Click(Sender);

}

HTML

K naÜemu prohlφ₧eΦi p°idßme nynφ indikßtor zpracovßnφ. Na stavovΘm °ßdku se nechßme informovat o stavu zavßd∞nφ strßnky. Vytvo°φme obsluhy udßlostφ OnUpdateRetrieval (informuje o pr∙b∞hu stahovßnφ) a OnEndRetrieval (dokonΦenφ stahovßnφ) komponenty HTML. Pro v²poΦet procenta zavedenφ pou₧ijeme vlastnosti GetBytesTotal (celkovß velikost dokumentu) a GetBytesDone (velikost ji₧ sta₧enΘ Φßsti dokumentu). Obsluha OnUpdateRetrieval je tvo°ena p°φkazy:

int total = HTML1->RetrieveBytesTotal;

int done = HTML1->RetrieveBytesDone;

int percent;

if (total == 0 || done == 0) percent = 0;

else percent = ((done * 100) / total);

char buff[80];

wsprintf(buff, "Getting Document: %d%% of %dK", percent, total / 1024);

StatusBar1->SimpleText = buff;

OnEndRetrieval

StatusBar1->SimpleText = "Done";

V naÜem prohlφ₧eΦi provedeme jeÜt∞ n∞jakΘ zm∞ny. Na panel pod kombinovan² ovladaΦ umφstφme Φty°i tlaΦφtka. U prvnφho z nich zm∞nφme vlastnost Caption na Go! a obsluha jeho stisknutφ bude tvo°ena p°φkazem:

ComboBox1Click(0);

Caption

Stop

HTML1->Cancel(0);

StatusBar1->SimpleText = "Done";

Caption

Reload

Caption

View Source

HTML1->ViewSource = !HTML1->ViewSource;

if (HTML1->ViewSource) Button4->Caption = "View Document";

else Button4->Caption = "View Source";

HTML

OnDoRequestDoc

StatusBar1->SimpleText = "Connecting to " + URL + "...";

OnBeginRetrieval

StatusBar1->SimpleText = "Connected...";

ComboBox1->Items->Insert(0, ComboBox1->Text);

OnKeyPress

Dßle se budeme zab²vat odesφlßnφm poÜty z aplikace. Odeslßnφ email nenφ t∞₧kΘ. Aplikace nap°. m∙₧e b²t tvo°ena komponentou Memo a tlaΦφtkem Send. U₧ivatel napφÜe text do komponenty Memo a stiskem tlaΦφtka jej odeÜle.

NMSMTP

Host

mail

NMSMTP

mail.mujpodnik.cz

Port

PostMessage

ToAddress

FromAddress

Subject

Body

NMSMTP

SMTP

Connect

SMTP->Host = "mail";

SMTP->Connect();

SMTP->PostMessage->FromAddress = "jmeno@spse.cz";

SMTP->PostMessage->ToAddress->Add("jmeno1@spse.cz");

SMTP->PostMessage->Subject = "Test";

SMTP->PostMessage->Body->Add("Toto je test");

SMTP->SendMail();

ToAddress

Body

TStringList

OnConnect

FromAddress

ToAddress

PostMessage

OnSuccess

SMTP->Disconnect();

OnFailure

POP3

Jak ji₧ vφme, knihovna vizußlnφch komponent je zapsßna v Object Pascalu. Nynφ se budeme zab²vat tφm, jak jazykovΘ slu₧by Object Pascalu jsou implementovßny v C++ Builderu. Tento popis je urΦen pro programßtory pou₧φvajφcφ objekty VCL ve sv²ch aplikacφch a pro v²vojß°e vytvß°ejφcφ novΘ t°φdy odvozenΘ od VCL t°φd.

Odkazy na C++ t°φdy odvozenΘ od TObject ukazujφ na t°φdy, pro kterΘ TObject je nutn², ale ne nutn∞ bezprost°ednφ, p°edek. Tyto t°φdy takΘ oznaΦujeme jako "t°φdy stylu VCL".

C++ a Object Pascal mßjφ jistΘ rozdφly ve vytvß°enφ, inicializaci, kopφrovßnφ a ruÜenφ objekt∙. S t∞mito rozdφly se seznßmφme podrobn∞ji.

V C++ instance t°φdy je aktußlnφ objekt. S objektem lze pracovat p°φmo nebo jej lze zp°φstupnit nep°φmo a to pomocφ odkazu nebo ukazatele. Nap°. pro t°φdu C++ jmΘna CPP_trida s konstruktorem bez parametr∙, jsou p°φpustnΘ vÜechny nßsledujφcφ instance tΘto t°φdy:

CPP_trida hodnotou; // objekt typu CPP_trida

CPP_trida& odkaz = hodnotou; // odkaz na objekt hodnotou

CPP_trida* prt = new CPP_trida(); // ukazatel na objekt typu CPP_trida

V Object Pascalu prom∞nnß typu objekt se v₧dy odkazuje na objekt nep°φmo. Pam∞¥ pro vÜechny objekty je alokovßna dynamicky. Nap°. pro t°φdu Object Pascalu OP_trida

odkaz: OP_trida;

odkaz := OP_trida.Create;

odkaz je odkaz na objekt typu OP_trida. V C++ Builderu bychom to zapsali takto:

OP_trida* odkaz = new OP_trida();

Mezi odkazy v C++ a Object Pascalu jsou jistΘ rozdφly. T∞mito rozdφly se nebudeme podrobn∞ji zab²vat. Abychom se t∞mto rozdφl∙m vyhnuli, vÜechny identifikßtory objekt∙ VCL jsou p°elo₧eny na ukazatele C++ v C++ Builderu.

Na rozdφl od C++, Object Pascal nemß zabudovanou podporu pro vytvß°enφ kopiφ objekt∙. Operßtor p°i°azenφ Object Pascalu (:=) nenφ p°i°azovacφm operßtorem t°φdy. V nßsledujφcφm k≤du, operßtor p°i°azenφ kopφruje odkaz a ne objekt. V nßsledujφcφm k≤du se B a C odkazujφ na stejn² objekt:

B, C: TButton;

B := TButton.Create(vlastniOvladac);

C := B;

P°edchozφ p°φklad je mo₧no p°elo₧it na nßsledujφcφ k≤d v C++ Builderu:

TButton* B = NULL;

TButton* C = NULL;

B = new TButton(vlastniOvladac);

C = B; // kopie ukazatele a ne objektu

T°φdy stylu VCL v C++ Builderu spl≥ujφ jazykovß pravidla Object Pascalu pro operßtor p°i°azenφ. Nßsledujφcφ k≤d je tedy nep°φpustn²:

TVCLStyleClass* p = new TVCLStyleClass;

TVCLStyleClass* q = new TVCLStyleClass;

*p = *q; // nenφ dovoleno pro t°φdy stylu VCL

nebo¥ se sna₧φ kopφrovat objekt a ne ukazatel.

Pro t°φdy stylu VCL je stßle p°φpustnΘ vytvß°enφ odkaz∙. Nap°. nßsledujφcφ k≤d je p°φpustn²:

TVCLStyleClass* ptr = new TVCLStyleClass;

TVCLStyleClass& odk = *ptr; // p°φpustnΘ

Object Pascal nemß kopφrovacφ konstruktor a tedy ani t°φdy stylu VCL v C++ Builderu nemajφ kopφrovacφ konstruktor. Nßsledujφcφ k≤d se pokusφ vytvo°it ukazatel na TButton pomocφ kopφrovacφho konstruktoru:

TButton* B = new TButton(vlastniOvladac);

TButton* C = new TButton(*B); // nenφ dovoleno pro t°φdy stylu VCL

Pro t°φdy VCL nezapisujeme k≤d, kter² p°edpoklßdß pou₧itφ kopφrovacφho konstruktoru. Pro vytvo°enφ kopie objektu t°φdy stylu VCL v C++ Builderu, m∙₧eme zapsat metodu, kterß kopφruje objekt. Potomci t°φdy TPersistent mohou takΘ p°edefinovat metodu Assign pro kopφrovßnφ dat z jednoho objektu do jinΘho. Toto se obvykle provßdφ u grafick²ch t°φd (nap°. TBitmap a TIcon), kterΘ obsahujφ zdroje obrßzk∙. Zp∙sob kopφrovßnφ objektu m∙₧e b²t urΦen tv∙rcem komponenty, ale nesmφme zapomenout, ₧e n∞kterΘ zp∙soby pou₧itelnΘ v C++ nejsou dostupnΘ pro t°φdy stylu VCL.

Je takΘ rozdφl ve zp∙sobu, kdy instance prom∞nnΘ odkazujφcφ se na objekty v C++ a v Object Pascalu, mohou b²t p°edßvßny funkcφm. V C++ objekty mohou b²t p°edßny funkci hodnotou, odkazem nebo ukazatelem. Object Pascal umo₧≥uje p°edßvat objekty hodnotou nebo odkazem. P°i p°edßvßnφ parametru hodnotou v Object Pascalu se ale takΘ ve skuteΦnosti jednß o p°edßvßnφ odkazu na objekt. V Object Pascalu nenφ tedy ekvivalent pro p°edßvßnφ objektu hodnotou v C++. TotΘ₧ platφ i pro t°φdy stylu VCL.

V C++ a Object Pascalu jsou takΘ vytvß°eny r∙zn∞ objekty. Ve standardnφm C++, po°adφ vytvß°enφ je: virtußlnφ zßkladnφ t°φda, nßsledovanΘ zßkladnφmi t°φdami a nakonec odvozenß t°φda. Syntaxe C++ pou₧φvß inicializaΦnφ seznam konstruktor∙ k volßnφ konstruktor∙ zßkladnφch t°φd. B∞hov² typ objektu je ta t°φda jejφ₧ konstruktor byl prßv∞ volßn. Vy°izovßnφ virtußlnφch metod se m∞nφ v pr∙b∞hu vytvß°enφ.

V Object Pascalu je zajiÜt∞no volßnφ pouze konstruktoru vytvß°enΘ t°φdy; nicmΘn∞ pam∞¥ pro zßkladnφ t°φdy je alokovßna. Vytvo°enφ ka₧dΘ zßkladnφ t°φdy je provedeno volßnφm inherited v konstruktoru odvozenΘ t°φdy. T°φdy VCL pou₧φvajφ inherited k volßnφ (neprßzdnΘho) konstruktoru zßkladnφ t°φdy. Nenφ to ale vy₧adovßno jazykem. B∞hov² typ objektu je urΦen bezprost°edn∞ a nem∞nφ se p°i volßnφ konstruktor∙ zßkladnφch t°φd. Vy°izovßnφ virtußlnφch metod se nem∞nφ v pr∙b∞hu vytvß°enφ.

Objekty stylu VCL jsou vytvß°eny podobn∞ jako objekty Object Pascalu, ale pomocφ syntaxe C++. To znamenß, ₧e zp∙sob a po°adφ volßnφ konstruktor∙ zßkladnφ t°φdy spl≥uje syntaxi C++, pou₧φvajφcφ seznam inicializacφ pro vÜechny zßkladnφ t°φdy neVCL a prvnφho bezprost°ednφho p°edka VCL. Tato zßkladnφ t°φda VCL je prvnφ t°φda, kterß bude vytvo°ena. Tedy zßkladnφ t°φdy VCL jsou vytvß°eny v opaΦnΘm po°adφ ne₧ v C++. B∞hov² typ objektu a zpracovßnφ virtußlnφch metod jsou zalo₧eny na Object Pascalu.

Virtußlnφ metody vyvolanΘ z t∞la konstruktor∙ zßkladnφ t°φdy VCL, tj. t°φd implementovan²ch v Object Pascalu, jsou zachytßvßny jako v C++, v zßvislosti na b∞hovΘm typu objektu. Proto₧e C++ Builder kombinuje model Object Pascalu, nastavovßnφ b∞hovΘho typu objektu bezprost°edn∞ s modelem C++ i vytvß°enφ zßkladnφch t°φd p°ed vytvß°enφm odvozen²ch t°φd, volßnφ virtußlnφch metod z konstruktor∙ zßkladnφch t°φd ve t°φdßch stylu VCL m∙₧e mφt zßke°nΘ vedlejÜφ efekty.

V Object Pascalu, programßtor m∙₧e pou₧φvat klφΦovΘ slovo inherited, kterΘ poskytuje flexibilitu pro volßnφ konstruktor∙ zßkladnφ t°φdy, kdekoliv v t∞le konstruktoru odvozenΘ t°φdy. Pokud odvozenß t°φda p°episuje n∞jakou virtußlnφ metodu, kterß zßvisφ na nastavenφ objektu nebo inicializaci datov²ch slo₧ek, pak to lze provΘst p°ed volßnφm konstruktoru zßkladnφ t°φdy a tedy p°ed vyvolßnφm virtußlnφch metod.

Syntaxe C++ nemß klφΦovΘ slovo inherited pro volßnφ konstruktoru zßkladnφ t°φdy v pr∙b∞hu vytvß°enφ odvozenΘ t°φdy. Nenφ to nutnΘ, nebo¥ b∞hov² typ objektu je urΦen prßv∞ vytvß°enou t°φdou a ne odvozenou t°φdou. Tedy vyvolanΘ virtußlnφ metody pat°φ do souΦasnΘ t°φdy a ne do odvozenΘ t°φdy. Nenφ tedy nutno inicializovat datovΘ slo₧ky nebo nastavovat objekt odvozenΘ t°φdy d°φve ne₧ tyto metody jsou volßny.

V C++ Builderu objekty stylu VCL majφ b∞hov² typ odvozenΘ t°φdy i p°i volßnφ konstruktoru zßkladnφ t°φdy. Pokud konstruktor zßkladnφ t°φdy volß virtußlnφ metodu, pak je vyvolßna metoda odvozenΘ t°φdy, pokud odvozenß t°φda ji p°edefinovßvß. Jestli₧e tato virtußlnφ t°φda zßvisφ na n∞Φem v inicializaΦnφm seznamu nebo v t∞le konstruktoru odvozenΘ t°φdy, pak metoda je volßna d°φve ne₧ to nastane. Virtußlnφ metody obvykle nevolßme v konstruktoru, ale jsou vyvolßny nep°φmo.

Nßsledujφcφ p°φklad porovnßvß t°φdy stylu C++ a VCL, kterΘ majφ p°ekrytΘ virtußlnφ metody. Tento p°φklad ukazuje jak volat tyto virtußlnφ metody z konstruktor∙ zßkladnφ t°φdy v obou p°φpadech. T°φdy MujZakl a MujOdv jsou standardnφ t°φdy C++. T°φdy MujVCLZakl a MujVCLOdv jsou t°φdy stylu VCL, odvozenΘ od TObject. Virtußlnφ metoda CoJsem je v obou odvozen²ch t°φdßch p°edefinovßna, ale je volßna pouze v konstruktorech zßkladnφch t°φd a ne v konstruktorech odvozen²ch t°φd.

#include <sysdefs.h>

#include <sysutils.hpp>

#include <iostream.h>

// T°φdy stylu C++

class MujZakl {

public:

MujZakl() { CoJsem(); }

virtual void CoJsem() { cout << "Jsem zßkladnφ" << endl; }

};

class MujOdv : public MujZakl {

public:

virtual void CoJsem() { cout << "Jsem odvozenß" << endl; }

};

// T°φdy stylu VCL

class MujVCLZakl : public TObject {

public:

__fastcall MujVCLZakl() { CoJsem(); }

virtual void __fastcall CoJsem() { cout << "Jsem zßkladnφ" << endl; }

};

class MujVCLOdv : public MujVCLZakl {

public:

virtual void __fastcall CoJsem() { cout << "Jsem odvozenß" << endl; }

};

int main(void)

{

MujOdv d; // instance t°φdy C++

MujVCLOdv *pvd = new MujVCLOdv; // instance t°φdy VCL

return 0;

}

V²stup z tohoto p°φkladu je:

Jsem zßkladnφ

Jsem odvozenß

proto₧e je rozdφl v b∞hov²ch typech MujOdv a MujOVLOdv b∞hem volßnφ jejich konstruktor∙ zßkladnφ t°φdy.

Jeliko₧ ve virtußlnφch funkcφch mohou b²t pou₧ity datovΘ slo₧ky, je d∙le₧itΘ znßt jak jsou inicializovßny. V Object Pascalu jsou vÜechna neinicializovanß data vynulovßna. V C++ to nenφ zajiÜt∞no. Nßsledujφcφ typy datov²ch slo₧ek t°φdy musφ b²t inicializovßny v inicializaΦnφm seznamu konstruktoru t°φdy: odkazy a datovΘ slo₧ky s neimplicitnφm konstruktorem.

Hodnoty datov²ch slo₧ek inicializovan²ch v t∞le konstruktoru jsou p°i volßnφ konstruktoru zßkladnφ t°φdy nedefinovßny. V C++ Builderu pam∞¥ pro t°φdy stylu VCL je vynulovßna (hodnoty jsou aktußln∞ nedefinovanΘ).

Virtußlnφ funkce pou₧φvajφcφ hodnoty prom∞nn²ch inicializovan²ch v t∞le konstruktoru nebo v inicializaΦnφm seznamu se chovajφ jako kdyby byly inicializovßny nulou. To proto, ₧e konstruktor zßkladnφ t°φdy je volßn p°ed zpracovßnφm inicializaΦnφho seznamu nebo provedenφm t∞la konstruktoru. Ukazuje to nßsledujφcφ p°φklad:

#include <sysdefs.h>

#include <sysutils.hpp>

class Base : public TObject {

public:

__fastcall Base() { init(); }

virtual void __fastcall init() { }

};

class Derived : public Base {

public:

Derived(int nz) : nenula(nz) { }

virtual void __fastcall init()

{

if (nenula == 0)

throw Exception("nenula je nula!");

}

private:

int nenula;

};

int main(void)

{

Derived *d42 = new Derived(42);

return 0;

}

Tento p°φklad generuje v²jimku v konstruktoru Base. Proto₧e Base je vytvß°ena p°ed Derived, nenula nenφ inicializovßna na hodnotu 42, p°edanou konstruktoru. Nem∙₧eme inicializovat datovΘ slo₧ky naÜich t°φd stylu VCL p°ed vyvolßnφm konstruktoru zßkladnφ t°φdy.

RuÜenφ objekt∙ se liÜφ ve dvou v∞cech v C++ od Object Pascalu: destruktory volan²mi z d∙vodu v²jimky vzniklΘ v konstruktoru a virtußlnφmi metodami volan²mi z destruktor∙. P°edpoklßdejme nßsledujφcφ p°φklad: t°φda C je odvozena od t°φdy B, kterß je odvozena od A.

class A

{

// t∞lo

};

class B: public A

{

// t∞lo

};

class C: public B

{

// t∞lo

};

P°edpoklßdejme, ₧e v²jimka vznikne v konstruktoru t°φdy B p°i vytvß°enφ instance C. V²sledek se liÜφ v C++, Object Pascalu a pro t°φdy stylu VCL:

V C++ je nejprve volßn destruktor pro vÜechny kompletn∞ vytvo°enΘ datovΘ slo₧ky B, potom je volßn destruktor A a nakonec jsou volßny destruktory pro vÜechny kompletn∞ vytvo°enΘ slo₧ky A. Destruktory B a C nejsou volßny.
V Object Pascalu je volßn automaticky pouze destruktor vytvß°enΘ t°φdy, tj. destruktor C. Stejn∞ jako v p°φpad∞ konstruktor∙, i u destruktor∙ je za volßnφ zd∞d∞n²ch destruktor∙ odpov∞dn² programßtor. V destruktoru C je nutno tedy volat dalÜφ pot°ebnΘ destruktory.
Pro t°φdy stylu VCL se pou₧φvajφ metody volßnφ destruktor∙ z Object Pascalu (pravΘ t°φdy VCL implementovanΘ v Object Pascalu). Pro t°φdy stylu VCL implementovanΘ v C++ toto p°esn∞ neplatφ. T°φdy implementovanΘ v Object Pascalu poskytujφ mo₧nost zpracovßnφ libovolnΘho uvol≥ovacφho k≤du zapsanΘho v t∞le destruktoru. To zahrnuje k≤d, kter² uvol≥uje pam∞¥ pro podobjekty (datovΘ slo₧ky, kterΘ jsou objekty), kterΘ jsou vytvo°eny p°ed vznikem v²jimky. Tento k≤d nesmφ b²t zpracovßn pro t°φdy stylu VCL implementovanΘ v C++.

Zpracovßnφ virtußlnφch metod v destruktorech se °φdφ stejn²mi pravidly jako jejich zpracovßnφ v konstruktorech. To znamenß, ₧e pro t°φdy stylu VCL je nejprve zruÜena odvozenß t°φda, ale b∞hov² typ objektu z∙stßvß nezm∞n∞n i p°i volßnφ destruktor∙ zßkladnφ t°φdy. Tedy, pokud virtußlnφ metody jsou volßny v destruktoru zßkladnφ t°φdy VCL, majφ b²t zpracovßny t°φdou, kterß ji₧ byla zruÜena.

TObject zavßdφ dv∞ virtußlnφ metody, BeforeDestruction a AfterConstruction, kterΘ umo₧≥ujφ programßtor∙m zapsat k≤d, kter² je zpracovßn p°ed zruÜenφm objektu a po vytvo°enφ objektu. AfterConstruction je volßn po vyvolßnφ poslednφho konstruktoru. BeforeDestruction je volßn p°ed volßnφm prvnφho destruktoru. Tyto metody jsou ve°ejnΘ a jsou volßny automaticky.

Object Pascal mß koncepci virtußlnφch funkcφ t°φdy. C++ mß analogii v statick²ch virtußlnφch funkcφch, ale C++ mß nep°esn² vztah k tomuto typu funkcφ. Tyto funkce jsou bezpeΦn∞ volßny z VCL, ale nikdy je nesmφme volat sami. K identifikaci t∞chto funkcφ v hlaviΦkov²ch souborech jsou p°edchßzeny komentß°em:

/* virtual class method */

Nynφ si na jednoduchΘ aplikaci ukß₧eme, jak m∞nit obsluhu n∞jakΘ udßlosti. ZaΦneme v²voj novΘ aplikace a na formulß° umφstφme tlaΦφtko. Jeho Caption zm∞nφme na Zm∞≥ obsluhu udßlosti. Stiskem tlaΦφtka budeme m∞nit obsluhu stisku tohoto tlaΦφtka. Obsluhu stisku tlaΦφtka tvo°φ p°φkazy:

MessageBox(NULL, "Obsluha udßlosti # 1", "Prvnφ", MB_OK);

Button1->OnClick = Button1Click2;

Button1Click2

void __fastcall TForm1::Button1Click2(TObject *Sender)

{

MessageBox(NULL, "Obsluha udßlosti # 2", "Druhß", MB_OK);

Button1->OnClick = Button1Click;

}

Dßle se op∞t podφvßme na ji₧ hotovou aplikaci. Stßhneme si ji a vyzkouÜφme. Tato aplikace mß kurzory a bitovΘ mapy nadefinovanΘ v souboru zdroj∙. Podφvejte se, jak tyto prvky jsou pou₧φvßny. Prostudujte si takΘ pou₧φvßnφ dalÜφch prvk∙ (nap°. komponenty TrackBar v dialogovΘm okn∞ voleb, zm∞nu volby Pause v nabφdce apod.).

19. InternetovskΘ aplikace