Pažintis su C++ Builder

Pažintis su C++ Builder Turinys C++ Builder aplinka... 2 Komponentai, jų savybės ir metodai, įvykiai... 2 Programos objektų savybių keitimas... 4 Vartotojo programos kūrimas, saugojimas ir vykdymas... 5 Pagrindiniai komponentai... 7 TForm - forma... 7 TLabel - žymė... 7 TButton - mygtukas... 7 TStaticText - teksto komponentas... 8 TEdit - redagavimo komponentas... 8 TMemo - teksto išvedimo komponentas... 8 Pagrindinės C++ duomenų struktūros ir konstrukcijos... 9 Kintamieji, priskyrimo sakinys... 9 Komentarai programoje... 10 Metodo iškvietimas... 10 TForm1 klasės struktūra... 11 Programų pavyzdžiai... 13 1 pavyzdys - Pirmoji programa... 13 2 pavyzdys - Komponento savybių keitimas... 15 3 pavyzdys - Skaičiavimas... 21 4 pavyzdys - Duomenų įvedimas ir skaičiavimas... 26 1

C++ Builder aplinka C++ Builder - tai objektiškai orientuotų programų kūrimo sistema, kurios priemonėmis galima paruošti įvairaus lygio ir paskirties programas: tiek mėgėjiškas, tiek profesionalias. Programos C++ Builder terpėje kuriamos, įtraukiant į programą reikalingus objektus (komponentus), suteikiant jiems reikalingas savybes ir programuojant C++ kalba reakcijas į įvykius, kurie gali įvykti programos vykdymo metu. Visų tų dalių sujungimą į vientisą C++ kalbos sintaksę atitinkančią programą automatiškai atlieka C++ Builder sistema. Pradėjus dirbti su C++ Builder, sukuriama integruota programų kūrimo terpė, kurioje yra visos priemonės, reikalingos vartotojo programoms projektuoti, kurti, testuoti ir derinti. Ekrane šią terpę sudaro 4 langai: pagrindinis C++ Builder langas (antraštė: C++Builder 5 - Project1), objektų inspektoriaus langas (Object Inspector), programos pagrindinės formos grafinio vaizdo langas (Form1) ir pagrindinės formos modulio programos langas (Unit1.cpp), kuris gali būti paslėptas po Form1 langu. 1.1 pav. parodytos pagrindinio C++ Builder lango, kuris užima tik viršutinę ekrano dalį, sudėtinės dalys: 1.1 pav. C++ Builder pagrindinis langas Komandų meniu - tai visų C++ Builder darbo metu galimų veiksmų rinkiniai. Kai kurie komandų rinkiniai, pavyzdžiui, File, Edit, Help, yra panašūs į kitų taikomųjų programų analogiškus rinkinius, o kai kurie, pavyzdžiui, Project, Run būdingi tik programų kūrimo terpėms. Komandų paskirtis paaiškės programų kūrimo metu. Dažniausiai naudojamos komandos pakartotos ir mygtukų juostose. Jų pavadinimai ir atliekami veiksmai sutampa su atitinkamų komandų pavadinimais ir atliekamais veiksmais. Dažniausiai mums bus reikalingi šie mygtukai: -saugoti viską (Save all), - vykdyti programą (Run), - atverti projektą (Open Project), - iš formos lango pereiti į modulio langą ir atvirkščiai (Toggle Form/Unit). Komponentai, jų savybės ir metodai, įvykiai Komponentai - tai objektai, iš kurių sudaroma C++ Builder terpėje kuriama programa. Visi komponentai yra griežtai tipizuoti ir vartotojo programose naudojami pagal to tipo komponentų paskirtį. Pavyzdžiui, programos mygtukams kurti gali būti taikomi TButton tipo komponentai. 2

Pagrindiniame C++ Builder lange komponentai yra sugrupuoti pagal paskirtį į atskirus sąrašus (paletes): Standard, Additional, Win32 irt.t. Vartotojo programoje visada bus bent vienas komponentas - forma (TForm tipo programos langas). Šis komponentas įkeliamas į kuriamą programą automatiškai, tik pradėjus C++ Builder darbą. Visi kiti reikalingi komponentai įtraukiami į programą tokiu būdu: reikia spragtelėti pele reikalingo komponento mygtuką komponentų paletėse, o po to - spragtelėti programos formos lange. Komponento matmenis ir vietą formos lange taip pat galima keisti pele. Tokiu pačiu būdu galima keisti ir programos pagrindinės formos lango matmenis bei vietą ekrane. Dešiniojo pelės klavišo spragtelėjimu ties komponentu galima iškviesti kontekstinį meniu, kuriame Align... komanda galima nustatyti tikslią komponento vietą (pavyzdžiui, lango centre), o Size... komanda - komponento matmenis. Į programą galima įtraukti bet kokį skaičių tiek to paties, tiek skirtingų tipų komponentų. Visiems jiems C++ Builder suteikia unikalius vardus, atspindinčius jų tipą. Pavyzdžiui, TLabel tipo komponentams, kurie naudojami įvairiems užrašams programos lange, bus suteikiami vardai Label1, Label2 ir t.t. Kiekvienas programos komponentas, kaip ir realaus pasaulio objektai, turi tam tikras savybes. Kai kurios savybės, pavyzdžiui, antraštė, spalva, ir pan., būdingos visų tipų komponentams, kai kurios - tik vieno kurio nors tipo komponentams. Kuriamos programos komponentų savybes peržiūrėti ir keisti galima objektų inspektoriaus (Object Inspector) lange, Properties plokštelėje (1.2.a pav.). Šiame lange rodomos savybės to programos objekto, kuris tuo metu yra aktyvus (prieš tai jame buvo spragtelėta pele). Kairiajame stulpelyje surašyti savybių pavadinimai abėcėlės tvarka, dešiniajame - reikšmės. Pakeitus kurios nors savybės reikšmę, atitinkamai pakinta objekto vaizdas programos lange (aišku, jei ši savybė nusako objekto vaizdą). Pavyzdžiui, pakeitus Caption (antraštė) reikšmę, pakinta užrašas objekto langelyje programos formos lange. 3

1.2 pav. Objektų instpektoriaus langas Galimas ir atvirkščias savybių reikšmių keitimas: formos lange pakeitus pele objekto dydį, pakinta ir atitinkamų savybių skaitinės reikšmės objektų inspektoriaus lange. Reikia nepainioti objekto antraštės (Caption) su objekto vardu (Name). Rekomenduotina, bent pirmose programose, objektų vardų nekeisti ir palikti tuos, kuriuos suteikia sistema (Form1, Label1, Label2, Edit1, Edit2 ir t.t.). Naujų objektų antraštėms sistema suteikia tokias pačias reikšmes kaip ir tų objektų vardams, tačiau antraštes tikslinga pakeisti tokiomis, kurios atspindi objektų paskirtį. Su kiekvienu programos objektu galima atlikti tam tikrus veiksmus (vykdyti objekto metodus), kurių sąrašas taip pat priklauso nuo objekto tipo. Objektų metodai dažniausiai taikomi programuojant veiksmus, kuriuos programa turėtų atlikti reaguodama į vienus ar kitus įvykius programos vykdymo metu. Įvykių, į kuriuos gali reaguoti objektas, sąrašas taip pat matomas objektų inspektoriaus lange Events plokštelėje (1.2.b pav.). Objekto reakcijos į vieną ar kitą įvykį (pavyzdžiui, mygtuko paspaudimą pele - OnClick) veiksmus turi suprogramuoti programos kūrėjas. Programos objektų savybių keitimas Tiek programos pagrindinės formos, tiek kitų į programą įtrauktų komponentų savybes galima apibrėžti (pakeisti) dviem būdais: 1) programos kūrimo ar modifikavimo metu, 2) programos vykdymo metu. Objektų savybių keitimas programos kūrimo metu. Šiuo atveju savybių reikšmės nurodomos objektų inspektoriaus lange. Pagal tai, kas gali būti savybės reikšme, galimi tokie variantai: 4

a) reikšmė - simbolių rinkinys arba skaičius: naują reikšmę galima tiesiog užrašyti atitinkamoje objektų inspektoriaus lango eilutėje; b) reikšmė - viena iš kelių galimų reikšmių: naują reikšmę galima išrinkti iš sąrašo paspaudus sąrašo išskleidimo mygtuką tos savybės eilutės dešinėje; c) savybė nusakoma parametrų rinkiniu: naujas savybę nusakančių parametrų reikšmes galima nustatyti dialogo lange, kuris pasirodo paspaudus dialogo lango atvėrimo mygtuką savybės eilutės dešinėje. Objektų savybių keitimas programos vykdymo metu. Šiuo atveju savybių keitimo veiksmai turi būti rašomi programoje C++ kalba. Dažniausiai tam naudojamas priskyrimo sakinys (žr. toliau). Vartotojo programos kūrimas, saugojimas ir vykdymas Kaip minėta, darbo pradžioje į programą įtraukiamas vienas TForm tipo komponentas - pagrindinis programos langas Form1. Grafinis šio lango vaizdas ir sugeneruota atitinkama programos kodo dalis parodyta 1.3.a pav. ir 1.3.b pav. Nors ši programa dar tik pradėta kurti, iš esmės ji turi visas pilnos programos savybes ir ją galima vykdyti (Run mygtuko paspaudimu). Po to, kai paspausite Run mygtuką, programa bus kompiliuojama ir vykdoma. Ekrane pasirodys tuščias pilkas langas su antrašte Form1. Šį langą galima kilnoti ekrane, keisti jo dydį pele. Lango uždarymo mygtukas nutraukia programos darbą. 1.3 pav. Vartotojo programos langai darbo pradžioje Programos naujos dalys įtraukiamos kaip nauji komponentai į pagrindinę programos formą arba kaip papildomos programos kodo dalys į programos tekstą. 5

Kad programa galėtumėte naudotis ne tik jos kūrimo metu, reikia išsaugoti ją kompiuterio diske. Kiekvienos programos saugojimui rekomenduotina pasidaryti atskirą katalogą, kadangi programos kompiliavimo metu sistema sukuria iki 10 failų. Po to, kai padarysite katalogą, viską galima išsaugoti vienu - Save All mygtuku. Atliekant tai pirmą kartą, dialogo languose reikės nurodyti pasirinktą katalogą, programos modulio bei projekto failų vardus (sistema siūlys Unit1. cpp ir Project1.bpr vardus atitinkamai). Kad neprarastumėte tai, ką padarote programos kūrimo metu, Save All mygtuką rekomenduotina paspausti po kiekvieno pakeitimo programoje. Tai užims labai nedaug laiko, kadangi failų vardus reikia nurodyti tik pirmo saugojimo pradžioje. 6

Pagrindiniai komponentai Šiame skyrelyje trumpai supažindinsime su tais vaizdinių C++ Builder komponentų tipais, kurie naudojami praktiškai visose, net ir pačiose paprasčiausiose programose. Aprašoma tik tos komponentų savybės ir metodai, kuriuos naudosime šio skyriaus programose. Label, Edit, Button komponentai yra Standard komponentų paletėje, StaticText - Additional komponentų paletėje. TForm - forma Pagrindinė paskirtis: formuoti programos langus, kuriuose dėliojami kiti programos komponentai. Programoje visada bus bent vienas šio tipo komponentas, kurį sistema pati įtraukia į programą ir suteikia Form1 vardą. Mūsų programose praktiškai visada užteks šios vienos formos. Dažniausias įvykis - kai forma tampa aktyvia (OnActivate). Caption savybė - simbolių eilutė (tekstas), kuri matoma komponento lango viršuje. Color savybė nusako formos komponento lango spalvą. Jos reikšme gali būti sistemoje naudojami spalvų pavadinimai (clblack, clmaroon, clgreen ir t.t.). ClientHeight, ClientWidth savybės nusako formos lango matmenis -aukštį ir plotį. Jų reikšmės - sveikieji skaičiai. TLabel - žymė Pagrindinė paskirtis - parodyti įvairiems užrašams formos lange (pačiame formos lange jokio teksto užrašyti negalima). Caption savybė - simbolių eilutė (tekstas), kuri matoma komponento lange. Font savybė nusako komponento teksto šriftą (dydį, stilių, spalvą ir kt). Kiekvienas šrifto parametras nustatomas atskirai. TButton - mygtukas Pagrindinė paskirtis - reaguoti į įvykius programos vykdymo metu. Dažniausias įvykis - mygtuko paspaudimas (OnClick). Caption savybė - simbolių eilutė (tekstas), kuri matoma komponento lange. Font savybė nusako komponento teksto šriftą (dydį, stilių, spalvą ir kt.). 7

Enabled savybė nusako, ar komponentas reaguoja į įvykius. Jei reikšmė yra true, mygtukas reaguoja į įvykius, jei false - nereaguoja. TStaticText - teksto komponentas Pagrindinė paskirtis - programos pranešimams ir rezultatams parodyti formoje. Caption savybė - simbolių eilutė (tekstas), kuri matoma komponento lange. BorderStyle nusako rėmelio apie komponentą tipą. Galimos reikšmės: sbsnone, sbssingle, sbssunken. TEdit - redagavimo komponentas Pagrindinė paskirtis - išsaugoti tekstą, kurį vartotojas įvedė šio komponento lange. Įvedimo metu tekstas gali būti redaguojamas. Text savybė - simbolių eilutė (tekstas), kuri matoma komponento lange. Programos vykdymo metu Edit komponento lange įvestas ar pakeistas tekstas tampa nauja Text savybės reikšme. Clear () metodas išvalo Edit komponento langą ir priskiria Text savybei tuščią eilutę. SetFocus () metodas perkelia įvedimo žymeklį į Edit komponento langą. TMemo - teksto išvedimo komponentas Pagrindinė paskirtis: saugoti, rodyti ekrane ir redaguoti tekstą, skirstomą eilutėmis. Pagrindinis skirtumas nuo TEdit komponento ir yra tai, kad tekstas skirstomas į eilutes. Savo pavyzdžiuose šį komponentą naudosime tekstinei informacijai kompiuterio ekrane rodyti tuo atveju, kai ši informacija gali būti ne vienoje eilutėje. Lines savybė - simbolių eilutės (tekstas), kurios matomos komponento lange. Iš tikrųjų, Lines yra TStrings klasės objektas. ScrollBars savybė nusako, ar bus slinkties juostos komponento lange. Galimos reikšmės: ssboth, sshorizontal, ssnone, ssvertical (abi, tik horizontali, nei vienos, tik vertikali). Slinkties juostos reikalingos tada, kai išvedama informacija gali netilpti komponento lange. Clear () metodas išvalo TMemo komponento langą ir pašalina visas eilutes. Lines->Add(E) metodas komponento teksto pabaigoje įrašo naują eilutę E. Lines->SaveToFile (FailoVardas) metodas komponento tekstą (visas eilutes) užrašo į tekstinį failą, kurio vardas yra FailoVardas. Jei tokio failo nėra, prieš užrašymą jis sukuriamas, jei yra - ištrinama visa jame esanti informacija. 8

Pagrindinės C++ duomenų struktūros ir konstrukcijos Reakcijos į įvairius įvykius veiksmams užrašyti C++ Builder sistemoje naudojama C++ programavimo kalba. Šiame skyrelyje susipažinsime su šios kalbos duomenų struktūromis ir konstrukcijomis, kurios bus naudojamos mūsų programose. Kintamieji, priskyrimo sakinys Kintamasis - tai turinti vardą "dėžutė", kurioje gali būti saugoma kokia nors reikšmė. Kintamojo vardas programoje nekinta, o jo reikšmė gali būti keičiama. Tarkime, kad kintamojo vardas yra n, o reikšmė turi būti lygi 10. Ši reikšmė minėtam kintamajam gali būti suteikta priskyrimo sakiniu, kuris C++ kalboje užrašomas tokiu būdu: n = 10; Tai reikia skaityti ne "n lygu 10", bet "kintamajam n priskirti reikšmę 10". Aukščiau užrašyta eilutė yra paprasčiausias C++ programavimo kalbos sakinys. C++ sakinių gale dedami kabliataškiai. Sakinys: n = n + 2; nėra matematinė lygtis. C++ kalboje tai reiškia: prie esamos kintamojo n reikšmės pridėti 2 ir rezultatą užrašyti į kintamąjį n vietoje buvusios reikšmės. C++ kalboje šį veiksmą galima užrašyti ir tokiu būdu: n += 2; Reikia atsiminti, kad priskyrimas: n = k + 5; keičia tik n reikšmę ir nekeičia k reikšmės. C++ kalba rašomoje programoje kintamuosius reikia paskelbti (aprašyti) prieš pirmąjį jų panaudojimą. Kintamieji kint1, kint2, kurių reikšmėmis bus sveikieji skaičiai (..., -3, -2, -l, 0, l, 2, 3,...), aprašomi tokiu būdu: int kinti; int kint2; arba int kinti, kint2;. Sakoma, kad šie kintamieji yra sveikųjų skaičių tipo. Kitų tipų kintamiesiems aprašyti naudojami tokie baziniai žodžiai: float - realiųjų skaičių (turinčių trupmeninę dalį) tipui, char - simbolių tipui (reikšmės - kompiuterio simboliai), AnsiString - simbolių eilutės tipui ir bool -loginiam tipui (reikšmės: true, false) nurodyti. Kintamųjų aprašo sakinyje jiems galima suteikti pradines reikšmes: int k = O; float r = 2.5; char c = 'A'; AnsiString E = "Jonas"; bool p = true; Priskyrimo sakiniu galima keisti ir programos komponentų savybių reikšmes. Jei keičiama savybė yra vienas iš komponento lango ekrane parametrų, pavyzdžiui, spalva, programos vykdymo metu atitinkamai pasikeis vaizdas ekrane. 9

Objekto savybės reikšmę programos vykdymo metu galima pakeisti tokios struktūros priskyrimo sakiniu: Objekto vardas->savybė = auja reikšmė; Pavyzdžiui, priskyrimo sakiniai StaticText1->Height = 400; StaticText1->Caption = " aujas tekstas"; StaticText1->Color = clred; StaticText1->Font->Size = 20; keičia programos objekto (komponento), kurio vardas StaticText1, savybių Height (aukštis), Caption (antraštė), Color (spalva) ir Font->Size (šrifto dydis) reikšmes. Height reikšmė yra sveikasis skaičius, Caption - simbolių eilutė (rašoma tarp kabučių), Color - viena iš kelių galimų reikšmių, Font - nusakoma parametrų rinkiniu, Size - vienas iš šių parametrų. Komentarai programoje Nors programos veiksmus atlieka ne žmogus, bet kompiuteris, tačiau dėl daugelio priežasčių programos kūrėjams dažnai tenka skaityti ir keisti programos tekstą. Todėl programos rašomos taip, kad būtų lengva jas skaityti: paliekami papildomi tarpai, tuščios eilutės, tekstas atitraukiamas nuo kairiojo krašto ir pan. Kartu programose labai naudingi paaiškinimai, padedantys geriau suprasti panaudotas duomenų struktūras ir atliekamus veiksmus. Tokie paaiškinimai (komentarai) programose C++ kalba pradedami dviem pasvirusiais brūkšneliais (//). Kompiuteris, kurioje nors programos eilutėje radęs //, už šių ženklų iki eilutės galo esantį tekstą ignoruoja ir kompiliavimo metu nenagrinėja. Eilutės su komentarais pavyzdys: StaticTextl->Color = clred; // nudažoma raudonai Metodo iškvietimas Kaip minėta anksčiau, kiekvienas programos objektas, turi ne tik tam tikras savybes, bet su juo galima atlikti ir tam tikrus veiksmus (vykdyti objekto metodus). Konkretaus objekto galimų metodų sąrašą galite rasti to objekto tipo aprašyme. Šį aprašymą galite rasti naudodamiesi C++ Builder pagrindinio lango Help komanda. Trumpesnis būdas: spragtelėti ties objektu programos formos lange arba ties objekto vardu programos teksto lange ir po to nuspausti <Ctrl>+<Fl> klavišų kombinaciją. Objekto metodą programos vykdymo metu galima iškviesti tokios struktūros sakiniu: Objekto vardas->metodo vardas (Parametrai); Žemiau užrašyti metodų iškvietimo sakinių pavyzdžiai kartu su komentarais: Edit1->Clear(); // išvalo Editl langą Form1->Close(); // užveria Form1 langą ir baigia programos darbą 10

Atkreipkite dėmesį į tai, kad skliausteliai būtini net ir tuo atveju, kai metodo iškvietime nenaudojami parametrai. Duomenų įvedimas ir išvedimas Beveik kiekvienoje programoje tenka numatyti duomenų įvedimo ir išvedimo veiksmus. Pirmosiose programose duomenų nebus daug, todėl juos įvesime klaviatūra, o išvesime į ekraną. Išvedimui naudosime aukščiau aprašytos TStaticText klasės komponentus, o įvedimui - TEdit klasės komponentus. Kadangi StaticText komponento Caption savybės reikšmė - simbolių eilutė, todėl, prieš suteikiant jai kokio nors programos kintamojo reikšmę, pastarąją iš skaitinės formos reikia pervesti į simbolinę formą. Sveikųjų skaičių tipo kintamųjų reikšmėms versti į simbolinę formą gali būti naudojama standartinė C++ Builder funkcija IntToStr, o realiųjų FloatToStr. Pavyzdžiui, IntToStr (n) verčia į simbolinę formą sveikojo kintamojo n reikšmę, FloatToStr (r) - realiojo kintamojo r reikšmę. Realiųjų skaičių vertimui į simbolių eilutę taip tinka ir FloatToStrF funkcija. Pavyzdžiui, FloatToStrF(r,ffFixed,8,2) suformuoja skaičiaus skaitmenų eilutę, kurioje visam skaičiui skirti 8 simboliai, o trupmeninė dalis apvalinama iki 2 skaitmenų. Programos vykdymo metu Edit komponento lange klaviatūra galima įvesti bet kokią informaciją. Šiame lange esanti informacija - simbolių eilutė - automatiškai perduodama Text savybei. Netgi klaviatūra įvesti skaitmenys traktuojami kaip simboliai. Simbolių eilutei versti į skaitinę formą gali būti taikomos C++ Builder funkcijos StrToInt ir StrToFloat. Pirmoji naudojama, jei simbolių eilutę reikia versti į sveikąjį skaičių, antroji -jei reikia versti į realųjį skaičių. Aišku, šiuo atveju simbolių eilutėje leistini tik tie simboliai, iš kurių galima sudaryti skaičių. Pavyzdžiui, StrToInt (Edit->Text) verčia Edit lange užrašytą simbolių seką į sveikąjį skaičių, StrToFloat (Edit->Text) - į realųjį skaičių. TForm1 klasės struktūra Kaip minėta, C++ Builder terpėje kuriama programa susideda iš objektų (komponentų), turinčių tam tikras savybes ir metodus. Bendru atveju objekto viduje gali būti ir kitų duomenų, kurie C++ kalboje vadinami laukais. Laukų, savybių ir metodų rinkinys sudaro to objekto tipą. C++ kalboje objekto tipui nusakyti naudojama klasės sąvoka. Programose visada pradžioje pateikiamas klasės aprašas, o tik po to - tos klasės objektų aprašai. Klasės yra objektiškai orientuotų programų esmė. Plačiau apie jų kūrimą ir naudojimą bus kalbama vėliau. Pirmosiose programose pakaks išmokti papildyti pagrindinio programos objekto - Form1 komponento klasę. Šio komponento klasės, turinčios TForm1 vardą, aprašą pamatysite faile, kurio vardo plėtinys.h TForm1 aprašas pradedamas eilute: class TForm1 : public TForm 11

Toliau tarp figūrinių skliaustų { surašomi į formą įtrauktų kitų komponentų vardai (kartu nurodoma ir komponento klasė) ir metodų antraštės. Tai padaro pati sistema formos kūrimo metu. Metodų tekstai surašomi faile, kurio vardo plėtinys yra.cpp. Kiekvienas metodas pradedamas antrašte, o tarp figūrinių skliaustų { programuotojas turi surašyti metodo viduje atliekamus veiksmus. Atkreipkite dėmesį į tai, kad klasių vardai pradedami T raide. TForm1 klasės apraše rasite žodžius private: ir public:. Tiek už žodžio private:, tiek už žodžio public: programuotojas gali rašyti savo kintamuosiuos ir metodus. Savo programose mes taikysime pirmąjį variantą, o apie šių variantų skirtumus bus kalbama vėliau. Klasės apraše, eilutėje fastcall TForm1 (TComponent* Owner); rasite specialaus metodo - klasės konstruktoriaus antraštę. Jis skirtas nurodytos klasės objekto sukūrimui. Metodo vardas sutampa su klasės vardu. Sistema įvykdo šį metodą automatiškai. Programuotojas šio metodo viduje gali suteikti pradines reikšmes pagrindinės formos kintamiesiems. Form1 komponento aprašą sudaro viena eilutė: TForm1 *Form1; Aprašydami kuriamas programas, visada pateiksime TForm1 klasės aprašą, kuriame nurodysime programos komponentų ir metodų paskirtį. Tai turėtų padėti suprasti programų veikimą. 12

Programų pavyzdžiai 1 pavyzdys - Pirmoji programa Užduotis. Sukurti programą, kuri atskirame lange parodytų tekstą "Sveiki!". Programos langas galėtų atrodyti taip: Piromosios programos darbo langas Tokia programa paprastai pradedama pažintis su bet kuria programavimo kalba. Programos kūrimas Pirmasis žingsnis. Pasiruošimas darbui. * Sukuriamas katalogas, kuriame bus saugomi visi šio darbo failai. Katalogo vardas pavyzdyje yra D01A. * Paleidžiamas dirbti C++ Builder. Ekrane C++ Builder aplinkoje bus sukuriamas ir naujos programos pagrindinis langas - pilkas Form1 langas. Tai tipiškas Windows aplinkos langas, turintis visas jam būdingas savybes. Forma tuščia. Po ja yra programos teksto langas. Čia jau yra programos dalis, kuri aprašo sukurtą formą. * Mygtukas Save All. Ekrane pasirodo langas Save Unit1 As. Prašoma parašyti programos failo vardą. Nustatomas katalogas D01A, kuriame bus saugomas programos failas. Parašomas programos vardas, pavyzdžiui D01AUnit1, ir paspaudžiamas mygtukas Save. Sukuriamas failas D01AUnit1.cpp. Langas užsidaro ir jo vietoje pasirodo kitas langas. * Langas SaveProject1 As. Prašoma parašyti programos projekto vardą. Katalogas D01A jau paruoštas. Parašomas failo vardas, pavyzdžiui D01APrj, ir paspaudžiamas mygtukas Save. Kataloge sukuriamas failas D01APrj.cpp. Langas uždaromas, sugrįžtama į C++ Builder aplinką. Kataloge D01A dabar rasite šešis failus: 13

D01APrj.bpr D01APrj.cpp D01APrj.res Programos projekto parametrų failas Projekto teksto failas Resursų failas Pagrindinės formos failas (grafinis D01AUnit1.dfm vaizdas) D01AUnit1.cpp Programos pagrindinės formos teksto failas D01AUnit1.h Formos klasės aprašo failas Nors nereikėjo nieko programuoti, jau turime pilną programą, kurią galima kompiliuoti ir vykdyti Run. Run komanda arba mygtuku. Ekrane gauname tuščią programos langą, turintį visas Windows terpės langų savybes: langas turi antraštę (Form1), galima keisti jo vietą ekrane bei matmenis ir uždaryti (baigti programą) mygtuku. Dabar kataloge D01A rasime dar keturis failus: D01APrj.exe D01APrj.obj D01APrj.tds Sukompiliuota programa Failo D01APrj.cpp objektinis kodas Programos derinimo informacijos failas Failo D01AUnit1.cpp objektinis D01AUnitl.obj kodas Antrasis žingsnis. Formos lango savybių keitimas. * Esant aktyviam Form1 langui, Object Inspector lange Properties plokštelėje yra Form1 savybių sąrašas: savybės vardas ir reikšmė. Savybių vardai surašyti abėcėlės tvarka. Vienos iš savybių - antraštės (Caption) - reikšmę Form1 pakeiskime į Pirmoji programa. Iš karto pasikeis ir Form1 lango viršuje matomas užrašas. Panašiu būdu galima keisti ir kitas savybes, tačiau, kaip minėta, nepatartina keisti komponento vardo ( ame savybė). Išmokite pakeisti Form1 lango matmenis (ClientHeight ir ClientWidth) ir spalvą (Color). Trečiasis žingsnis. Komponento, reikalingo tekstui užrašyti, sukūrimas ir užpildymas. 14

* Ekrane yra tuščias programos formos langas Form1. Standard komponentų paletėje pele paspauskite mygtuką. Tokiu būdu išrenkamas TLabel komponentas, kurį pelės spragtelėjimu galima padėti į bet kurią Form1 lango vietą. Sukuriamas stačiakampis laukas su jo viduryje esančiu pavadinimu Label1. Tuo pačiu į Form1 įtraukiamas naujas objektas - Label1 komponentas. Jei šis komponentas yra aktyvus, Object Inspector lange, matomas jo savybių sąrašas. Pakeiskite Caption reikšmę iš Label1 į Sveiki!. Išmokite dešiniuoju pelės mygtuko nuspaudimu iškviesti kontekstinį meniu. Pasinaudodami šiuo būdu padėkite Label1 komponentą tiksliai į formos centrą (Align... komandoje pasirinkite Horizontal ir Vertical išdėstymo variantą Center in Window). * Font savybės lauke spragtelėjus pele pasirodo laukelis su mygtuku. Paspauskite šį mygtuką. Atsivers Font dialogo langas su paslaugų sąrašais. Nurodykite tokias reikšmes: Font: Times ew Roman, Font Style: Regular, Size: 14, Color: Black, Script: Baltic. * Paspauskite mygtuką OK. Label1 komponento langelyje tekstas bus parašomas nurodyto tipo, stiliaus ir dydžio šriftu. Ketvirtasis žingsnis. Programos bandymas. * Save All mygtuku pagrindiniame C++ Builder lange išsaugokite visus padarytus veiksmus. * Pagrindinio sistemos lango Run mygtuku kompiliuokite ir vykdykite programą. Jeigu kompiliuojant programą bus klaidų, tuomet lango D01AUnit1.cpp (programos teksto langas) apačioje bus pranešimai apie klaidas. Jeigu nėra klaidų, tuomet programa iš karto pradedama vykdyti. Ekrane gaunamas langas vardu "Pirmoji programa", kurio centre bus tekstas "Sveiki!". Mūsų programos langas turi visas Windows langų savybes: galima pele perkelti į kitą ekrano vietą, keisti dydį, dešinėje viršuje jis turi tris mygtukus. Sumažinus lango dydį tiek, kad jame nebetilptų užrašas, kraštuose atsiranda peržiūros juostos. Programos darbo langas uždaromas (tuo pačiu baigiamas programos darbas) mygtuku. Kadangi visą programos tekstą sugeneravo pati C++ Builder sistema, čia jis nepateikiamas ir neanalizuojamas. 2 pavyzdys - Komponento savybių keitimas Užduotis. Sukurti programą, kurioje vieno mygtuko paspaudimu programos lango dalis būtų nudažoma žaliai, o kito mygtuko paspaudimu - raudonai. Programoje taip pat turi būti mygtukas, kurį nuspaudus bus baigiamas programos darbas. Programos aprašymas. Kaip ir 1 pavyzdyje, pradžioje sukursime katalogą, parinksime pagrindinės formos lango matmenis, spalvą ir antraštę (detaliau šių veiksmų nebeaprašinėsime). 15

Kadangi galima nudažyti tik visą kurio nors komponento langą, programos lango dalyje, kurią norime dažyti, įdėsime naują komponentą - StaticText1. * Komponentų paskirtis: Vardas Form1 Paskirtis Pagrindinė programos forma StaticText1 Dažomas komponentas Button1 Button2 Button3 Mygtukas, kurį nuspaudus StaticText1 žaliai nudažomas Mygtukas, kurį nuspaudus StaticText1 raudonai nudažomas Mygtukas, kurį nuspaudus baigiamas programos darbas Šio pavyzdžo formos schema * Objektų inspektoriuje keičiamos komponentų savybių reikšmės: Vardas Keičiama savybė Reikšmė Form1 Caption Savybių keitimas StaticText1 Caption Paspauskite "Žalią" arba "Raudoną" mygtuką 16

BorderStyle sbssunken Button1 Caption Žalias Button2 Caption Raudonas Button3 Caption Baigti * Programos komponentai reaguoja į šiuos įvykius: Komponentas Įvykis Vykdomas metodas Button1 Button2 Button3 OnClick Button1Click OnClick Button2Click OnClick Button3Click * TForm1 klasės aprašo failas: -- #ifndef D01BUnit1H #define D01BUnit1H -- #include <Classes. hpp> #include <Controls. hpp> #include <StdCtrls. hpp> #include <Forms.hpp> -- class TForm1 : public TForm { published: // IDE-managed Components TStaticText *StaticText1; TButton *Button1; TButton *Button2; TButton *Button3; void fastcall Button1Click (TObject *Sender); void fastcall Button2Click (TObject *Sender); void fastcall Button3Click (TObject *Sender); private: // User declarations public: // User declarations fastcall TForm1(TComponent* Owner); 17

; -- extern PACKAGE TForm1 *Form1; -- #endif Metodų aprašai * TForm1::Button1Click(TObject *Sender) - nudažo StaticText1 langą žaliai. Atlieka tokius veiksmus: StaticText1->Color = clgreen; // Keičia spalvą StaticText1->Caption = " udažėme žaliai"; // Keičia antraštę * TForm1::Button2Click(TObject *Sender) -nudažo StaticText1 langą raudonai. Atlieka tokius veiksmus: StaticText1->Color = clred; // Keičia spalvą StaticText1->Caption = " udažėme raudonai"; // Keičia antraštę * TForm1::Button3Click(TObject *Sender) - uždaro Form1 langą ir baigia programos darbą. Atlieka tokius veiksmus: Close(); // Vykdo Form1->Close() metodą Atmintinė vartotojui Programa saugoma D01B kataloge D01BPrj.bpr, D01BPrj.cpp, D01BPrj.res, D01BUnit1.cpp, D01BUnit1.dfm ir D01BUnit1.h failuose. Programos tekstas Žemiau pateikiamas trijų tekstinių programos failų: projekto - D01BPrj.cpp, formos klasės aprašo - D01BUnit1.h ir formos modulio - D01BUnit1.cpp tekstai. Projekto failą D01BPrj. cpp pilnai sugeneruoja sistema, ir jo tekstas visoms programoms yra toks pats, todėl kituose pavyzdžiuose šio failo nerodysime. Jo turinio kol kas taip pat neanalizuosime. Formos klasės aprašo failo D01BUnit1.h tekste pusiau juodu šriftu užrašytos eilutės, kuriose yra į programą įtrauktų komponentų StaticText1, Button1, Button2 ir Button3 aprašai ir metodų Button1Click, Button2Click ir Button3Click, atliekančių reakcijos į mygtukų paspaudimus veiksmus, antraštės. Visą failo tekstą sugeneruoja C++ Builder sistema programos kūrimo metu. Kadangi TForm1 klasės aprašas pateikiamas atskirai,.h tipo failų kituose pavyzdžiuose taip pat nerodysime. 18

Formos modulio failo D01BUnit1.cpp tekste pusiau juodu šriftu užrašyti metodų veiksmai. Šias eilutės buvo užrašytos, programuojant reakcijos į mygtukų paspaudimus veiksmus. Visas kitas failo eilutes sugeneruoja sistema. //------------------------------D01BPrj.cpp------------------------------ #include <vcl.h> #pragma hdrstop USERES("D01BPrj.res"); USEFORM("D01BUnit1.cpp", Form1); //--------------------------------------------------------------------------- WI API WinMain(HI STA CE, HI STA CE, LPSTR, int) { try { Application->Initialize(); Application->CreateForm( classid(tform1), &Form1); Application->Run(); catch (Exception &exception) { Application->ShowException(&exception); return 0; //------------------------------D01BUnit1.h------------------------------ #ifndef D01BUnit1H #define D01BUnit1H #include <Classes.hpp> #include <Controls.hpp> #include <StdCtrls.hpp> #include <Forms.hpp> class TForm1 : public TForm { published: // IDE-managed Components TStaticText *StaticText1; TButton *Button1; TButton *Button2; TButton *Button3; void fastcall Button1Click(TObject *Sender); 19

void fastcall Button2Click(TObject *Sender); void fastcall Button3Click(TObject *Sender); private: // User declarations public: // User declarations fastcall TForm1 (TComponent* Owner); ; - extern PACKAGE TForm1 *Form1; - #endif //------------------------------D01BUnit1.cpp---------------------------- #include <vcl.h> #pragma hdrstop #include "D01BUnit1.h" #pragma package (smart_init ) #pragma resource "*.dfm" TForm1 *Form1; fastcall TForm1 :: TForm1 (TComponent* Owner) : TForm(Owner) { void fastcall TForm1 :: Button1Click (TObject *Sender) { StaticText1->Color = clgreen; StaticText1->Caption = " udažėme žaliai"; void fastcall TForm1 :: Button2Click (TObject *Sender) { StaticText1->Color = clred; StaticText1->Caption = " udažėme raudonai"; void fastcall TForm1 :: Button3Click (TObject *Sender) { Close(); 20

2 pavyzdžio programos darbo langas 3 pavyzdys - Skaičiavimas Užduotis. Sukurti programą, kuri atliktų visus 2 pavyzdyje pateiktos programos veiksmus ir kartu skaičiuotų, kiek kartų buvo nuspaustas "Žalias" ir kiek kartų "Raudonas" mygtukas. Programos aprašymas * Komponentų paskirtis: Vardas Paskirtis Forml pagrindinė programos forma StaticTextl dažomas komponentas Buttonl mygtukas, kurį nuspaudus StaticTextl nudažomas žaliai Button2 mygtukas, kurį nuspaudus StaticTextl nudažomas raudonai Button3 mygtukas, kurį nuspaudus baigiamas programos darbas Label1 ir Label4 programos paaiškinimų langai StaticText2 "Žalio" mygtuko nuspaudimų kiekiui parodyti StaticText3 "Raudono" mygtuko nuspaudimų kiekiui parodyti 21

3 pavyzdžo formos schema * Objektų inspektoriuje keičiamos komponentų savybių reikšmės: Vardas Keičiama savybė Reikšmė Form1 Caption Savybių keitimas StaticText1 Caption BorderStyle Paspausk "Žalią" arba "Raudoną" mygtuką. sbssunken Button1 Caption Žalias Button2 Caption Raudonas Button3 Caption Baigti Label1 Caption "Žalias" mygtukas nuspaustas Label2 Caption "Raudonas" mygtukas nuspaustas Label3 Caption k. Label4 Caption k. StaticText2 Caption 0 22

BorderStyle sbssunken StaticText3 Caption 0 BorderStyle sbssunken * Programos komponentai reaguoja į šiuos įvykius: Komponentas Įvykis Vykdomas metodas Button1 OnClick Button1Click Button2 OnClick Button2Click Button3 OnClick Button3Click * TForm1 klasės aprašo failas: #ifndef D01cUnit1H #define D01cUnit1H #include <Classes.hpp> #include <Controls.hpp> #include <StdCtrls.hpp> #include <Forms.hpp> class TForm1 : public TForm { published: // IDE-managed Components TStaticText *StaticText1; TButton *Button1; TButton *Button2; TButton *Button3; TLabel *Label1; TLabel *Label2; TLabel *Label3; TLabel *Label4; TStaticText *StaticText2; TStaticText *StaticText3; void fastcall Button1Click(TObject *Sender); void fastcall Button2Click(TObject *Sender); void fastcall Button3Click(TObject *Sender); 23

private: // User declarations int zalias, raudonas; // nuspaudimų kiekiai public: // User declarations fastcall TForm1 (TComponent* Owner); ; - extern PACKAGE TForm1 *Form1; /- #endif * Kintamieji: Į TForm1 klasės aprašą private dalyje įtraukti du papildomi sveikųjų skaičių tipo kintamieji zalias ir raudonas. Jie reikalingi mygtukų nuspaudimų kiekiams skaičiuoti. Metodų aprašai * TForm1 :: TForm1 (TComponent* Owner) - priskiria kintamiesiems pradines reikšmes: zalias = 0; raudonas = 0; * TForml :: Button1Click (TObject *Sender) - nudažo StaticText1 langą žaliai. Atlieka tokius veiksmus: StaticText1->Color = clgreen; // Keičia spalvą StaticText1->Caption = "Nudažėme žaliai"; // Keičia antraštę zalias += 1; // didina reikšmę vienetu StaticText2->Caption = IntToStr (zalias) ; // išveda kintamojo reikšmę į StaticText2 langą * TForm1 :: Button2Click (TObject *Sender) - nudažo StaticText1 langą raudonai. Atlieka tokius veiksmus: StaticText1->Color = clred; // Keičia spalvą StaticText1->Caption = "Nudažėme raudonai"; // Keičia antraštę raudonas += 1; // didina reikšmę vienetu StaticText3->Caption = IntToStr (raudonas); // išveda kintamojo reikšmę į StaticText3 langą * TForm1 :: Button3Click (TObject *Sender) - uždaro Form1 langą ir baigia programos darbą. Atlieka tokius veiksmus: Close(); // Vykdo Form1->Close () metodą Atmintinė vartotojui Programa saugoma D01C kataloge D01CPrj.bpr, D01CPrj.opp, D01CPrj.res, D01CUnit1.cpp, D01CUnit1.dfm ir D01CUnit1.h failuose. 24

Programos tekstas //-------------------------------D01CUnit1.cpp--------------------------- #include <vcl.h> #pragma hdrstop #include "D01cUnit1.h" #pragma package (smart_init ) #pragma resource "*.dfm" TForm1 *Form1; fastcall TForm1 :: TForm1 (TComponent* Owner) : TForm(Owner) { zalias = 0; raudonas = 0; void fastcall TForm1 :: Button1Click (TObject *Sender) { StaticText1->Color = clgreen; StaticText1->Caption = " udažėme žaliai"; StaticText1->Color = clgreen; // Keičia spalvą StaticText1->Caption = " udažėme žaliai"; // Keičia antraštę zalias += 1; // didina reikšmę vienetu StaticText2->Caption = IntToStr (zalias) ; // išveda kintamojo reikšmę į StaticText2 langą void fastcall TForm1 :: Button2Click (TObject *Sender) { StaticText1->Color = clred; StaticText1->Caption = " udažėme raudonai"; StaticText1->Color = clred; // Keičia spalvą StaticText1->Caption = " udažėme raudonai"; // Keičia antraštę raudonas += 1; // didina reikšmę vienetu StaticText3->Caption = IntToStr (raudonas); // išveda kintamojo reikšmę į StaticText3 langą void fastcall TForm1 :: Button3Click (TObject *Sender) { Close(); 25

3 pavyzdžio programos darbo langas 4 pavyzdys - Duomenų įvedimas ir skaičiavimas Užduotis. Sukurti programą, kuri atliktų paprasto kalkuliatoriaus funkcijas, t.y. jos priemonėmis būtų galima atlikti dviejų klaviatūra įvedamų realiųjų skaičių sudėtį, atimtį, daugybą ir dalybą. Programos aprašymas * Komponentų paskirtis: Form1 Vardas Edit1, Edit2 Button1 Button2 Button3 - Button6 Paskirtis pagrindinė programos forma duomenų įvedimo langeliai mygtukas, kurį nuspaudus baigiamas programos darbas mygtukas įvedimo ir išvedimo langeliams išvalyti mygtukai aritmetiniams veiksmams (sudėčiai, atimčiai, dalybai, daugybai) atlikti Label1 - Label3 programos paaiškinimų langai 26

StaticText1 aritmetinio veiksmo rezultato langelis 4 pavyzdžo formos schema * Objektų inspektoriuje keičiamos komponentų savybių reikšmės: Vardas Form1 Keičiama savybė Caption Reikšmė Duomenų įvedimas ir skai-čiavimas (kalkuliatorius) Edit1, Edit2 Text Button1 Caption Baigti Button2 Caption Valyti Button3 Caption + Button4 Caption - Button5 Caption / Button6 Caption * Label1 Caption? Label2 Caption = Label3 StaticText1 Caption Caption BorderStyle Užrašyk skaičius ir paspausk reikalingą mygtuką sbssunken 27

Pastaba. Tuščias reikšmės langelis reiškia tuščią simbolių eilutę. * Programos komponentai reaguoja į šiuos įvykius: Komponentas Įvykis Vykdomas metodas Form1 OnActivate FormActivate Button1 OnClick Button1Click Button2 OnClick Button2Click Button3 OnClick Button3Click Button4 OnClick Button4Click Button5 OnClick Button5Click Button6 OnClick Button6Click * TForm1 klasės aprašo failas: //-------------------------------------------------------------- #ifndef D01DUnit1H #define D01DUnit1H //-------------------------------------------------------------- #include <Classes.hpp> #include <Controls.hpp> #include <StdCtrls.hpp> #include <Forms.hpp> //-------------------------------------------------------------- class TForm1 : public TForm { published: // IDE-managed Components TButton *Button1; TButton *Button2; TLabel *Label1; TLabel *Label2; TStaticText *StaticText1; TEdit *Edit1; TEdit *Edit2; TButton *Button3; TButton *Button4; 28

TButton *Button5; TButton *Button6; TLabel *Label3; void fastcall FormActivate (TObject *Sender); void fastcall Button1Click (TObject *Sender); void fastcall Button2Click (TObject *Sender); void fastcall Button3Click (TObject *Sender); void fastcall Button4Click (TObject *Sender); void fastcall Button6Click (TObject *Sender); void fastcall Button5Click (TObject *Sender); private: // User declarations float rez; // aritmetinio veiksmo rezultatas public: // User declarations fastcall TForm1(TComponent* Owner); ; //-------------------------------------------------------------- extern PACKAGE TForm1 *Form1; //-------------------------------------------------------------- #endif * Kintamieji: Į TForm1 klasės aprašą private dalyje įtrauktas papildomas realusis kintamasis rez. Šis kintamasis skirtas aritmetinio veiksmo rezultatui saugoti. Metodų aprašai * TForm1 :: FormActivate (TObject *Sender) - perkelia įvedimo žymeklį į pirmojo skaičiaus langelį: Edit1->SetFocus(); * TForm1 :: Button1Click (TObject *Sender) - baigia programos darbą: Close (); * TForm1 :: Button2Click (TObject *Sender) - išvalo įvedimo ir išvedimo langelius: Edit1->Clear(); Edit2->Clear(); Label1->Caption = "?"; StaticText1->Caption = ""; * TForm1 :: Button3Click (TObject *Sender) - sudeda įvestus skaičius: 29

Label1->Caption = "+"; rez = StrToFloat(Edit1->Text) + StrToFloat(Edit2->Text); StaticText1->Caption = FloatToStrF (rez,fffixed,8,2); * TForm1 :: Button4Click (TObject *Sender) - iš 1-ojo skaičiaus atima 2-ąjį: Label1->Caption = "-"; rez = StrToFloat (Edit1->Text) - StrToFloat(Edit2->Text); StaticText1->Caption = FloatToStrF(rez,ffFixed,8,2); * TForm1 :: Button5Click (TObject *Sender): - 1-ąjį skaičių padalija iš 2-ojo: Label1->Caption = "/"; rez = StrToFloat(Edit1->Text) / StrToFloat(Edit2->Text); StaticText1->Caption = FloatToStrF(rez,ffFixed,8,2); * TForm1 :: Button6Click (TObject *Sender) - sudaugina skaičius: Label1->Caption = "*"; rez = StrToFloat(Edit1->Text) * StrToFloat(Edit2->Text); StaticText1->Caption = FloatToStrF(rez,ffFixed,8,2); Atmintinė vartotojui Programa saugoma D01D kataloge D01DPrj.bpr, D01DPrj.cpp, D01DPrj.res, D01DUnit1.cpp, D01DUnit1.dfm ir D01DUnit1.h failuose. Vykdant programą reikia neužmiršti, kad joje nėra apsaugos nuo klaidingų duomenų įvedimo. T.y. įvedami skaičiai turi tenkinti C++ kalbos realiųjų skaičių sintaksės reikalavimus. Be to, dalyba iš nulio yra negalima. Programos tekstas // ---------------------------------D01DUnit1.cpp------------------------ #include <vcl.h> #pragma hdrstop #include "D01DUnit1.h" - #pragma package (smart_init ) #pragma resource "*.dfm" 30

TForm1 *Form1; - fastcall TForm1 :: TForm1 (TComponent* Owner) : TForm(Owner) { - void fastcall TForm1 :: FormActivate (TObject *Sender) { Edit1->SetFocus(); - void fastcall TForm1 :: Button1Click (TObject *Sender) { Close(); - void fastcall TForm1 :: Button2Click (TObject *Sender) { Edit1->Clear(); Edit2->Clear(); Label1->Caption = "?"; StaticText1->Caption = ""; - void fastcall TForm1 :: Button3Click (TObject *Sender) { Label1->Caption = "+"; rez = StrToFloat(Edit1->Text) + StrToFloat(Edit2->Text); StaticText1->Caption = FloatToStrF(rez,ffFixed,8,2); - void fastcall TForm1 :: Button4Click (TObject *Sender) { Label1->Caption = "-"; rez = StrToFloat(Edit1->Text) - StrToFloat(Edit2->Text); StaticText1->Caption = FloatToStrF (rez,fffixed,8,2); - void fastcall TForm1 :: Button5Click (TObject *Sender) { Label1->Caption = "/"; rez = StrToFloat(Edit1->Text) / StrToFloat(Edit2->Text); 31

StaticText1->Caption = FloatToStrF(rez,ffFixed,8,2); - void fastcall TForm1 :: Button6Click(TObject *Sender) { Label1->Caption = "*"; rez = StrToFloat(Edit1->Text) * StrToFloat(Edit2->Text); StaticText1->Caption = FloatToStrF(rez,ffFixed,8,2); - 4 pavyzdžio programos darbo langas 32

Literatūra 1. C++ Builder labaratoriniai darbai <http://cppb.ten.lt> 33