Marian Mysior

Pascal, Delphi…,

a moŜe Lazarus?

ĆWICZENIA

Wydawnictwo EscapeMagazine.pl

Pascal, Delphi..., a może Lazarus? Ćwiczenia

Marian Mysior

Wydanie pierwsze

Toruń 2013

ISBN: 978-83-61744-65-8

Wszelkie prawa zastrzeżone!

Autorzy oraz Wydawnictwo dołożyli wszelkich starań, aby informacje zawarte w tej

publikacji były kompletne, rzetelne i prawdziwe. Autorzy oraz Wydawnictwo nie ponoszą

żadnej odpowiedzialności za ewentualne szkody wynikające z wykorzystania informacji

zawartych w publikacji lub użytkowania tej publikacji.

Wszystkie znaki występujące w publikacji są zastrzeżonymi znakami firmowymi bądź

towarowymi ich właścicieli.

Rozpowszechnianie całości lub fragmentu w jakiejkolwiek postaci jest zabronione.

Kopiowanie, kserowanie, fotografowanie, nagrywanie, wypożyczanie, powielanie

w jakiekolwiek formie powoduje naruszenie praw autorskich.

bezpłatny fragment

Wydawnictwo EscapeMagazine.pl

http://www.EscapeMagazine.pl

4

Spis treści

Wstęp 8

Rozdział 1. Środowisko programowania 11

1.1. Pierwsza aplikacja 12

Ćwiczenie 1. Zaczynamy 13

1.2. Wprowadzanie danych, formatowanie wyników 15

Ćwiczenie 2. Obliczamy objętość kuli 15

Ćwiczenie 3. Inaczej wprowadzamy dane i wyprowadzamy wyniki 18

Ćwiczenie 4. Używamy okna MessageDlg 22

Ćwiczenie 5. Nie używamy trybu graficznego 24

Rozdział 2. Podstawy języka 27

2.1. Instrukcje wyboru 27

Ćwiczenie 6. Obliczamy pierwiastki trójmianu kwadratowego 27

Ćwiczenie 7. Sprawdzamy w kalendarzu 30

2.2. Instrukcje powtarzania 32

Ćwiczenie 8. Drukujemy tabelę funkcji trygonometrycznych 33

Ćwiczenie 9. Szukamy największego wspólnego dzielnika 36

Ćwiczenie 10. Obliczamy wartość funkcji silnia 37

2.3. Tablice 39

Ćwiczenie 11. Sito Eratostenesa 40

Ćwiczenie 12. Obliczamy dokładnie silnię z 1000 43

2.4. Rekordy, pliki 46

Ćwiczenie 13. Zapisujemy daty urodzin 47

5

Ćwiczenie 14. Zapisujemy dane do pliku 50

Rozdział 3. Kontrolki, zdarzenia 54

3.1. Metody obsługi zdarzeń 54

Ćwiczenie 15. Testujemy kontrolki 55

3.2. Kontrolki usprawniają wprowadzanie danych 58

Ćwiczenie 16. Wprowadzamy dane, używając kontrolek 59

Rozdział 4. Kontrola poprawności danych, obsługa sytuacji wyjątkowych 65

4.1. Weryfikacja danych 66

Ćwiczenie 17. Sprawdzamy dane funkcją „TryStrToFloat” 66

Ćwiczenie 18. Sprawdzamy dane funkcją „Val” 68

Ćwiczenie 19. Tworzymy kalendarz z pełną kontrolą danych 70

Ćwiczenie 20. Obliczamy dzień Wielkanocy z maską wprowadzania 74

4.2. Strukturalna obsługa wyjątków 77

Ćwiczenie 21. Przechwytujemy błąd 78

Ćwiczenie 22. Analizujemy rodzaj błędu 80

Ćwiczenie 23. Zgłaszamy własny wyjątek 83

Ćwiczenie 24. Sprzątamy po błędzie 85

4.3. Śledzenie zmiennych, praca krokowa 87

Ćwiczenie 25. Sprawdzamy wartości zmiennych 88

Rozdział 5. Interfejs użytkownika 90

5.1. Menu 90

Ćwiczenie 26. Tworzymy edytor tekstu z menu 90

5.2. Pasek narzędzi 95

Ćwiczenie 27. Budujemy pasek narzędzi 96

6

5.3. Pasek stanu 98

Ćwiczenie 28. Dodajemy pasek stanu 98

5.4. Obsługa plików 100

Ćwiczenie 29. Zapisujemy i odczytujemy pliki 100

5.5. Drukowanie 106

Ćwiczenie 30. Przygotowujemy wydruk 106

Rozdział 6. Grafika 109

6.1. Podstawowe obiekty i metody graficzne 109

Ćwiczenie 31. Rysujemy podstawowe elementy graficzne 109

Ćwiczenie 32. Tworzymy obraz na mapie bitowej 112

Ćwiczenie 33. Otwieramy obrazy w kontrolce TImage 114

Ćwiczenie 34. Używamy figur z kontrolki TShape 115

6.2. Sposoby uzyskiwania animacji 117

Ćwiczenie 35. Kopiujemy mapę bitową 117

Ćwiczenie 36. Pobieramy fazy ruchu z plików 120

Ćwiczenie 37. Przesuwamy kontrolki korzystając z właściwości Left i Top 122

Rozdział 7. Bazy danych 124

7.1. Prosta baza danych 124

Ćwiczenie 38. Tworzymy prostą bazę danych 124

7.2. Obsługa systemów zarządzania bazami danych 132

Ćwiczenie 39. Podłączamy bazę typu MS Access poprzez ODBC 132

Rozdział 8. Własne klasy 136

8.1. Obiekty 138

Ćwiczenie 40. Definiujemy obiekt 138

7

8.2. Pierwsza klasa 140

Ćwiczenie 41. Definiujemy własną klasę 140

8.3. Hermetyzacja 141

Ćwiczenie 42. Tworzymy metody udostępniające pola obiektu 142

Ćwiczenie 43. Używamy właściwości 146

8.4. Konstruktory i destruktory 149

Ćwiczenie 44. Tworzymy własny konstruktor 149

8.5. Dziedziczenie 151

Ćwiczenie 45. Budujemy klasę potomną 151

8.6. Metody wirtualne 154

Ćwiczenie 46. Wywołujemy właściwe metody 154

8.7. Tablice w obiektach 160

Ćwiczenie 47. Korzystamy z tablicy za pomocą właściwości 160

Rozdział 9. Rozmaitości 163

9.1. Moduły 163

Ćwiczenie 48. Drukujemy słownie wartości liczbowe 164

9.2. Własne kontrolki 171

Ćwiczenie 49. Tworzymy własną kontrolkę 171

9.3. Optymalizacja plików wykonywalnych 176

Ćwiczenie 50. Symbole debugowania umieszczamy w oddzielnym pliku 176

Ćwiczenie 51. Usuwamy informacje debugowania z pliku wykonywalnego 177

Zakończenie 178

Inne książki autora 179

8

Wstęp

Pascal jeszcze niedawno był jednym z najpopularniejszych języków programowania.

Jest uniwersalnym językiem wysokiego poziomu, ogólnego zastosowania. Opraco-

wany został przez Niklausa Wirtha w 1970 roku. Oparty jest na wcześniej używanym

języku Algol. Nazwa języka pochodzi od nazwiska francuskiego fizyka, matematyka

i filozofa Blaise Pascala.

Podręcznik Niklausa Wirtha „Algorytmy + Struktury Danych = Programy”, będący

klasyką nauczania algorytmiki, doczekał się 3 wydań w języku polskim (wyd. WNT,

Warszawa, 1980, 1989, 2004). Pascal jest w nim językiem publikacyjnym. Do dziś jest

powszechnie stosowanym językiem programowania w edukacji.

Pierwsze pojawienie się języka Pascal, wspierającego programowanie obiektowe

odbyło się w 1983 r. Producentem była firma komputerowa Apple. Później

hegemonię przejęła firma Borland International ze swoją powszechnie znaną linią

produktów Turbo Pascal i Delphi.

W 1995 roku ukazała się pierwsza wersja Delphi (16-bitowa). Przeznaczona była

do pracy w środowisku graficznym Microsoft Windows 3.1. Było to jedno

z pierwszych narzędzi typu Rapid Application Development (szybkie tworzenie

aplikacji). Delphi 2.0 (1996) było już produktem 32 bitowym, pracującym pod

kontrolą systemu operacyjnego Windows 95/NT.

Po pojawieniu się na rynku programistycznym Microsoft Visual Studio .NET,

również Borland International wyprodukował Delphi for .NET (2003 rok). Od tego

momentu mamy dwie linie produktów Delphi: Delphi for Win32 i Delphi for .NET.

Uczniowie, studenci i pasjonaci mogli je używać bezpłatnie w wersjach oznaczonych

jako Personal.

Niestety w 2006 roku Borland International powołał do życia spółkę zależną

CodeGear, której przekazał swoje prawa do Delphi, aby następnie w 2008 roku

sprzedać ją firmie Embarcadero Technologies. Nie oznaczało to zaprzestania rozwoju

Delphi, ale jednak dalsze komercjalizowanie tego produktu. Od tej chwili nawet

wersje edukacyjne są narzędziami płatnymi. Dwie linie Delphi nazwano

odpowiednio: Embarcadero Delphi i Embarcadero Prism. Są bardzo udanymi

i cenionymi produktami na rynku profesjonalistów. Pasjonatom pozostało płacić za

9

nie lub szukać alternatywnych produktów (ewentualnie korzystać ze starszych

produktów Borlanda).

Dobrą i bezpłatną alternatywą dla Delphi jest Lazarus. To wieloplatformowe,

zintegrowane środowisko programistyczne IDE (Integrated Development

Environment) , oparte na kompilatorze Free Pascal. Działa według zasady: „write

once, compile anywhere”, czyli napisz raz (kod źródłowy), skompiluj gdziekolwiek.

Inaczej mówiąc, raz napisany kod można skompilować pod różne systemy

operacyjne. Obecnie Lazarus dostępny jest między innymi dla następujących

platform: Windows 32/64, Windows CE, Mac OS X, Linux, Unix, Android. Ćwiczenia

realizować będziemy pod kontrolą systemu Windows.

Podstawowe informacje o środowisku Lazarus można znaleźć na stronie:

http://www.lazarus.freepascal.org. Tam też znajdziemy odsyłacz umożliwiający

pobranie i zainstalowanie najnowszej wersji produktu. W 2012 roku oddana została

do użytku pierwsza, finalna wersja: Lazarus 1.0.

Tworzenie aplikacji można podzielić na trzy zasadnicze fazy: analizowanie,

projektowanie i programowanie (kodowanie). Podział ten ma szczególne znaczenie

dydaktyczne. Kłopoty z prawidłowym działaniem aplikacji mają często źródło

w powierzchownej bądź błędnej analizie problemu, w złym (nieprzemyślanym)

projekcje. Emocjonalne podejście do programowania przez wielu programistów

powoduje niedocenianie dwóch pierwszych faz, czego efektem jest program błędny

lub gorszy od oczekiwań. Efektywne tworzenie aplikacji powinno składać się nie

z jednorazowej analizy, projektowania i programowania, lecz z równoczesnego

rozwijania wszystkich tych faz. Aby udoskonalać i poprawiać swój produkt należy

wielokrotnie powracać po fazie programowania do ponownej analizy lub do

projektowania. Jest to tzw. model piłki baseballowej.

PROJEKTOWANIE ANALIZOWANIE

PROGRAMOWANIE

10

Finalnym zapisem algorytmu rozwiązania problemu jest kod źródłowy (skrypt)

zapisany w języku programowania. Dalej następuje proces kompilacji i uruchamiania

programu. Często używanymi narzędziami są tutaj środowiska zintegrowane (IDE).

Potrzeby obecnych użytkowników oprogramowania wymagają, aby aplikacje

dysponowały graficznymi interfejsami (były „okienkowe”). To z kolei rodzi wyma-

gania względem środowisk programistycznych, które muszą być efektywne.

Archaicznym podejściem do nauki programowania jest wykorzystywanie narzędzi,

które nie zapewniają wspomagania graficznego w tworzeniu interfejsów, nie

preferują programowania obsługującego zdarzenia i programowania obiektowego.

Te pojęcia nie muszą oznaczać „wyższego wtajemniczenia” w sztukę progra-

mowania. Nie należy klasyfikować je, jako problemy zaawansowane. Od nich

musimy zaczynać nie tylko programowanie, ale już analizę problemu i projektowanie

rozwiązania. Współczesne środowiska zintegrowane umożliwiają jak nigdy dotąd

tworzenie programów obiektowych, sterowanych zdarzeniami i silnie wspoma-

ganych graficznie. Od samego początku wykorzystujemy tutaj (przynajmniej

pasywnie) właściwości i metody obiektów, nawet nie wspominając o nich.

W sytuacjach, gdy interfejs graficzny jest zbędny lub przeszkadza w „zgłębieniu

istoty problemu” można zbudować aplikację konsolową.

Kody źródłowe można pobrać ze strony wydawnictwa. Odnośnik znajduje się na

końcu książki.

11

Rozdział 1. Środowisko programowania

Środowiska zintegrowane zwalniają programistę z „ręcznego” pisania całego kodu,

oferując graficzne wspomaganie już podczas wybierania typu projektu oraz w czasie

umieszczania komponentów na formularzach (w oknach). Znacząco przyspiesza to

cały proces tworzenia programu i odciąża programistę od pamięciowego opano-

wywania wielu szczegółów. Po wybraniu odpowiadającego nam projektu, auto-

matycznie utworzony zostanie szkielet przyszłego programu, zawierający na start

nawet kilkadziesiąt wierszy kodu źródłowego.

W Lazarusie możemy tworzyć 3 typy projektów: Aplikacja, Program, Console

application. Domyślnym typem projektu jest „Aplikacja”, czyli „program okienkowy”.

„Program” to natomiast minimalistyczny projekt w stylu archaicznego już Turbo

Pascala, pracujący w trybie tekstowym. Console application również pracuje

w trybie tekstowym, ale tworzy program z nową klasą pochodzącą z TCustom-

Application. Oferuje ona kilka ułatwień, np. obsługę wyjątków, sprawdzenie opcji

wiersza polecenia, pisanie pomocy, sprawdzanie zmiennych środowiskowych.

IDE Lazarusa jest podobne do środowisk Delphi. Pozwala również importować

projekty napisane wcześniej dla Delphi.

Rysunek 1.1 IDE Lazarusa

12

1.1. Pierwsza aplikacja

Ćwiczenia realizować będziemy w środowisku zintegrowanym Lazarus 1.0.4.

Warto na początku wyłączyć skróty klawiaturowe, blokujące dostęp do polskich

znaków „ł” i „ś”. Zrobimy to, klikając w menu „Narzędzia” i kolejno wybierając:

Opcje…/Edytor/ Klawisze skrótu/Menu widok/View Local Variables.

W oknie dialogowym wyłączamy sekwencję „Alt-l”.

Rysunek 1.2. Wyłączenie blokady „ł”.

Podobnie postąpimy ze skrótem „Alt-s”. Znajdziemy go w tym samym miejscu,

dwie pozycje niżej (polecenie: Pokaż stos wywołań).

Podczas pracy w środowisku Lazarus często wykorzystywać będziemy menu

„Projekt”, a w nim szczególnie:

• Nowy projekt … – tworzy nowy projekt

• Otwórz projekt … – otwiera istniejący projekt

• Zamknij projekt … – zamyka projekt

• Lista modułów – wyświetla listę modułów projektu (można otworzyć

wybrany moduł do edycji)

• Lista formularzy – wyświetla listę formularzy projektu (można otworzyć

wybrany formularz do edycji)

W czasie edycji kodu źródłowego i redagowania formularzy użyteczne są przyciski

„Przełącz pomiędzy formularzem i modułem” oraz „Zapisz wszystko”.

13

Ćwiczenie 1. Zaczynamy

Uruchomimy program Lazarus.

W otwartym środowisku zobaczymy projekt formularza i kilka innych okien.

Projekt formularza będzie później oknem naszej aplikacji.

Warto już teraz zadbać o zapisanie projektu na dysku. W tym celu naciśniemy

przycisk Zapisz wszystko, na pasku narzędzi (polecenie o takiej samej nazwie

znajdziemy też w menu Plik). Projekt możemy zapisać w dowolnym folderze. Warto

jednak założyć oddzielny folder na projekty Lazarusa, np. „Lazarus-projekty”. Dla

każdego projektu założymy własny podfolder. W naszym przypadku będzie to folder

o nazwie „Pierwszy”. Przyciskiem Zapisz potwierdzimy zapisanie plików projektu.

Zatwierdzimy dwie domyślne nazwy plików: project1.lpr i unit1.pas. W folderze

naszego projektu zapisanych zostanie jeszcze kilka innych plików.

Typy plików:

Nazwa pliku Opis

project1.lpr Kod źródłowy głównego modułu, zapisany w Pascalu

unit1.pas Kod źródłowy modułu skojarzonego z formularzem, zapisany w Pascalu

project1.ico Plik ikony projektu

project1.lpi Plik informacyjny projektu (zapisany w formacie XML; zawiera ustawienia specyficzne dla projektu, takie jak ustawienia kompilatora i wymaganych pakietów). Dwukrotne kliknięcie w ten plik otwiera projekt w środowisku Lazarusa

project1.lps Plik sesji, przechowywany w pliku XML, zawiera indywidualne dane, takie jak pozycja kursora, edytor plików źródłowych, sposób kompilacji

project1.res Plik zasobów

unit1.lfm Plik formularza, zawiera informacje o konfiguracji wszystkich obiektów na formularzu (przechowywane w określonym formacie tekstowym, podobnie jak w Delphi: dfm; działanie opisane jest kodem źródłowym Pascala w pliku unit1.pas)

project1.exe Plik wykonywalny, utworzony po kompilacji

14

Z lewej strony ekranu znajdziemy okno o nazwie Inspektor obiektów. Znajdziemy

w nim właściwość formularza: Caption. Wpiszemy tam tekst „Pierwszy program”

(zamiast Form1). Będzie to tytuł naszego formularza.

Rysunek 1.3. Inspektor obiektów

Na formularzu umieścimy napis (etykietę): „Mój pierwszy program”. Zrobimy to

korzystając z paska Lazarus Component Library (LCL). Zawiera on projekty różnych

kontrolek (inaczej komponentów albo formantów). Wybierzemy kontrolkę TLabel

i naniesiemy ją na formularz (podobnie jak rysuje się elementy graficzne w edytorze

graficznym). W oknie właściwości, które automatycznie wyświetla właściwości

wybranego formantu, odszukamy pozycję Caption i wpiszemy swój tekst.

Rysunek 1.4. Pasek formantów z biblioteki LCL

Możemy jeszcze zadbać o jego wygląd. Właściwość Font pozwala nam wybrać

atrybuty czcionki (rodzaj, wielkość, kolor itp.). Po kliknięciu na tej właściwości

najlepiej wybrać przycisk […]. Otwiera on okno dialogowe Czcionka (podobne jak

15

w edytorach tekstu). Dla przykładu wybierzemy czcionkę „Mistral”, rozmiar: 20, styl:

pogrubiona.

Nasz pierwszy program jest gotowy. Utworzyliśmy go korzystając jedynie

z narzędzi graficznych, nie pisząc kodu „ręcznie”. Możemy teraz wypróbować

produkt, uruchamiając go ze środowiska zintegrowanego. W tym celu wybieramy

przycisk Uruchom (�) z paska narzędzi. Alternatywne sposoby to menu

Uruchom/Uruchom, lub klawisz F9. Program można oczywiście uruchamiać spoza

środowiska zintegrowanego. Odnajdziemy go w swoim folderze Pierwszy.

Rysunek 1.5. Pierwszy program w działaniu

1.2. Wprowadzanie danych, formatowanie wyników

Tylko najprostsze programy tworzymy bazując całkowicie na kodzie pisanym

automatycznie. Program rozwiązujący nawet nieskomplikowane zadanie mate-

matyczne wymaga napisania odpowiednich formuł, podania danych i wyprowa-

dzenia wyników.

Ćwiczenie 2. Obliczamy objętość kuli

Otworzymy środowisko Lazarusa. Nowy projekt zapiszemy w folderze „Kula”.

Analiza problemu:

Zastosujemy wzór na obliczanie objętości kuli v = 4/3 π r3.

16

Projekt:

• Objętość kuli zależy od jej promienia, więc na formularzu umieścimy

następujące kontrolki:

o Etykietę (TLabel) z napisem „Podaj promień:”

o Pole tekstowe (TEdit), w którym wymażemy napis domyślny

z właściwości Text i wpiszemy wartość domyślną „0”.

• Wstawimy drugą etykietę (usuniemy napis domyślny), do wyprowadzenia

wyników.

• Obliczenia zostaną uruchomione po podaniu promienia i naciśnięciu

odpowiedniego przycisku. Przycisk (TButton) wstawimy z paska LCL na

projekt formularza. Jego właściwości Caption nadamy wartość „Oblicz”.

• Uruchomimy edycję metody obsługi zdarzenia „przy kliknięciu”, klikając

dwukrotnie na projekcie przycisku. W ten sposób zaczynamy ręczne

wprowadzanie kodu. Nagłówek tej metody (procedury) utworzony

zostanie automatycznie i nie należy zmieniać go.

Programowanie (pisanie kodu):

procedure TForm1.Button1Click(Sender: TObject);

var

r, v: single;

begin

r:=StrToFloat(Edit1.Text);

v:=4/3*pi*r*r*r;

Label3.Caption:=FloatToStr(v);

end;

Prześledźmy wprowadzony kod.

Nagłówek procedury został dodany automatycznie. Słowa begin i end tworzą

„nawiasy”, odpowiednio otwierający i zamykający ciało procedury, które musimy

teraz zdefiniować.

17

Przed ciałem procedury umieszczamy deklaracje zmiennych. Rozpoczynamy je

słowem var. Po nim następują deklaracje. W naszym przypadku deklarujemy użycie

dwóch zmiennych r i v, typu single.

Język Pascal wymaga deklarowania typów zmiennych (danych) przed ich użyciem.

Tabela prezentuje dopuszczalne typy danych.

Typ Zakres Rodzaj – rozmiar Boolean True, False Logiczny, 8 bitów ByteBool 0 – False; Inna wart. – True Logiczny, 8 bitów WordBool 0 – False; Inna wart. – True Logiczny, 16 bitów LongBool 0 – False; Inna wart. – True Logiczny, 32 bity Double ±5.0 × 10-324 do ±1.7 × 10308

Precyzja: 15-16 cyfr Liczba zmiennopozycyjna (rzeczywista), 64 bity

Single ±1.5 × 10-45 do ±3.4 × 1038 Precyzja: 7 cyfr

Liczba zmiennopozycyjna (rzeczywista), 32 bity

Extended 1.9 × 10-4932 do 1.1 × 104932 Precyzja: 19-20 cyfr

Liczba zmiennopozycyjna (rzeczywista), 80 bitów

Byte 0 do 255 Bez znaku, liczba całkowita, 8 bitów ShortInt -128 do 127 Ze znakiem, liczba całkowita, 8 bitów SmallInt -32,768 do 32,767 Ze znakiem, liczba całkowita, 16

bitów Integer,

LongInt -2,147,483,648 do 2,147,483,647

Ze znakiem, liczba całkowita, 32 bity

LongWord,

Cardinal 0 do 4,294,967,295 Bez znaku, liczba całkowita, 32 bity

Int64 -9,223,372,036,854,775,808 do 9,223,372,036,854,775,807

Ze znakiem, liczba całkowita, 64 bity

Word 0 do 65535 Bez znaku, liczba całkowita, 16 bitów QWord 0 do 18,446,744,073,709,551,615 Bez znaku, liczba całkowita, 64 bity Comp -2×1064+1 ..

2×1063-1

Precyzja: 19-20 cyfr

Liczba całkowita (w zapisie zmiennopozycyjnym), 64 bity

Currency -922337203685477,5808 do 922337203685477,5807

Liczba stałopozycyjna,64 bity

Char U+0000 do U+ffff Znaki Unicode, 16 bitów String Do 2 miliardów znaków Łańcuch znakowy w kodzie Unicode

18

Dane wprowadzane do okna edycyjnego TEdit są zawsze łańcuchem znaków

(właściwość Text). Należy przekształcić je w liczbę odpowiedniego typu. Wykonu-

jemy to, używając funkcji StrToFloat(Edit1.Text):

r:=StrToFloat(Edit1.Text);

Objętość wyliczymy z zależności: v=4/3Πr3. Liczba π jest funkcją stałą. Dostęp do

niej uzyskamy pisząc po prostu pi.

v:=4/3*pi*r*r*r;

Dane wyprowadzamy do etykiety (TLabel) na formularzu. Właściwość Caption

etykiety wymaga podania łańcucha znaków. Wartość v musimy więc skonwertować

do postaci łańcucha. Zrobimy to używając funkcji FloatToStr(v):

Label3.Caption:=FloatToStr(v);

Jeżeli otrzymany wynik chcemy zaokrąglić do określonej liczby miejsc

dziesiętnych (np. 2 miejsca po przecinku), zamiast funkcji FloatToStr(v)

możemy użyć funkcji FloatToStrF(…):

Label3.Caption:=FloatToStrF(v,ffFixed,10,2);

Rysunek 1.6. Objętość kuli

19

PEŁNA WERSJA

http://www.escapemagazine.pl/369727-pascal-delphi-a-moze-lazarus