Lazarus

A Free Pascal rendelkezik a Delphi-hez hasonló grafikus felülettel, amely kiváló RAD (gyors alkalmazásfejlesztő) eszközzé teszi. A gazdag VCL (Visual Component Library) lehetővé teszi, hogy egy-egy feladatra gyorsan “összeüssünk” egy működő programot. A kód nem feltétlenül lesz bármilyen szempontból optimalizált, azonban ez csak ritkán jelent problémát, a tervezéskor a kitűzött cél az volt, hogy az irodai környezetben gyakran előforduló feladatokra a lehető legkisebb élőerő ráfordítással lehessen programot készíteni. A rugalmasságát jól jelzi a Write once compile anywhere (írd meg és fordítsd le bármire) szlogen. Ez azt jelenti, hogy megfelelő körültekintéssel olyan programok készíthetőek e rendszer segítségével, amelyek bármely támogatott architektúrára lefordíthatóak és ott futtathatóak. Az ilyen programok írásakor azonban le kell mondanunk az egyes platformok specifikus előnyeiről.

LazarusNew

A Lazarus képes lefordítani a standard Delphi programokat, amennyiben azok nem tartalmaznak különleges ( például: OCX, DCU) kódot.

A Lazarus rendszerben egy új projekt a File/New... menüpontban feljövő párbeszéd ablakban lehet kezdeni. A feljövő lehető lehetőségek bőségesek.

A bal oldalon kiválasztott lehetőségeket a jobb oldalon angolul érthetően elmagyarázza.

Ha a gyors alkalmazásfejlesztést szeretnénk kipróbálni, akkor a File/New…/Project/Application menüpontot választjuk.

LazarusProj

Ekkor megjelenik egy üres programpanel és néhány kiegészítő adat, valamint felül a választható komponensek listája, baloldalt a kiválasztott elem tulajdonságai (“beállításai”) láthatóak.

A felső sávban a kiválasztott komponensre kattintunk, majd a formon arra a helyre ahova a komponenst tenni szeretnénk. A futó programon nem minden komponens lesz látható, hiszen például a TMYQL50Connection nem rendelkezik vizuális megjelenéssel.

Internet logo

Free Pascal 2

Az előző részben a Free Pascal fordító alapvető biztonsági beállításait vettük szemügyre. A mostani rész a programok optimalizálásával foglalkozik.

Mivel a Pascal elterjedtsége meg sem közelíti a C jellegű nyelvekét, mi elsősorban az üzemeltetési feladatok automatizálására használjuk. A gyakran ismétlődő vagy hosszadalmas feladatoknál jelentős szerepe van a sebességre való optimalizálásnak.

Az optimalizálás első kérdése, hogy mire optimalizálunk:

  • Sebességre
  • Memória használatra
  • Program méretre
  • Átláthatóságra

A program tervezésénél mindhárom szempontot figyelembe lehet venni, de sok esetben az optimalizálás – egy határon túl – a kiválasztott szempont szerinti teljesítményének növelését jelenti a többi rovására.

Az optimalizálást mindig a pontos feladatkírással és a megfelelő algoritmusok megválasztásával kell kezdeni.
A példaprogramunk egy egyszerű rendező algoritmus lesz, mivel azon az elmondottak jól bemutathatóak. A programok nem egy jól használható rendezőalgoritmus, hanem egy gondolatmenet bemutatására szolgálnak, ezért egy naiv algoritmust választunk,  mivel abban nagy fejlesztési potenciál van.

Program rendez;
Uses sysutils;
Const

meret=30000;

Var

tomb:array [1..meret] of real; //A rendezendő tömb
tmp:real;
i,j:integer; //Ciklusváltozók

begin
Randomize;
// A tömb feltöltése véletlen számokkal
For I:=1 to meret do
Begin
tomb[I]:=random;
End;
//A rendezés
Writeln (‘Kezd : ‘,TimeToStr(time));
For I:=meret downto 1 do
begin
For j:=1 to I-1 do
begin
If tomb[j]<tomb[j+1] then
Begin
tmp:=tomb[j];
tomb[j]:=tomb[j+1];
tomb[j+1]:=tmp;
end;
end;
end;

Writeln (‘Vege : ‘,TimeToStr(time));
end.

 

A program a legegyszerűbb buborékrendezést valósítja meg, mindenféle optimalizálás nélkül.

Ha a programot úgy módosítjuk, hogy kihasználjuk a már rendezett elemek adta lehetőségeket a program futási idejét várhatóan a felére csökkenthetjük, azonban a csökkenés mértéke függ a kiindulási rendezettségtől.

Program rendez2;
Uses sysutils;
Const

meret=32000;

Var
rendben:boolean;
tomb:array [1..meret] of double; //A rendezendő tömb
tmp:real;
i,j:integer; //Ciklusváltozók

begin
Randomize;
// A tömb feltöltése véletlen számokkal
For I:=1 to meret do
Begin
tomb[I]:=random;
End;
//A rendezés

Writeln (‘Kezd : ‘,TimeToStr(time));
For I:=meret-1 downto 1 do
begin
J:=I-1;
rendben:=false;
repeat
j:=j+1;
If (tomb[j]<tomb[j+1]) then
Begin
tmp:=tomb[j];
tomb[j]:=tomb[j+1];
tomb[j+1]:=tmp;
end
else
begin
rendben:=true;
end;
//    writeln (j);
until (j=meret);
end;
Writeln (‘Vege : ‘,TimeToStr(time));

end.

Természetesen vannak ennél (jelentősen) hatékonyabb megoldások is, azonban annak bemutatására, hogy józan gondolkodással egy program futási ideje töredékére csökkenthető megfelel.

FPC

Free Pascal

A Free Pascal (régebben FPK Pascal) egy nyílt forráskódú  pascal fordító és fejlesztőkörnyezet, amelynek célja a Turbo Pascal kiváltása.

A Free pascal lehetőségei ma már túlmutatnak a példakép Turbo Pascal lehetőségein, követve az Turbo Pascal fejlesztésének leállítása után keletkezett elvárásokat.

A következő operációs rendszerek alá lehet vele programot fejleszteni:

 

A következő processzorokat támogatja:

  • Intel x86
  • AMD64/x86-64
  • PowerPC
  • PowerPC64
  • SPARC
  • ARM
  • m68K (csak a régebbi verziók támogatják)

Támogatott adatbázis formátumok:

  • Advantage
  • Microsoft SQL Server
  • Interbase
  • MySql
  • Postgresql
  • Oracle Database
  • Firebird
  • SQLite
  • Sybase Adaptive Server Enterprise
  • ODBC
  • FoxPro
  • DBase
  • Paradox
  • Text fájl alapú adatbázis

A fenti hosszú felsorolásokat röviden összefoglalva a Free Pascal segítségével szinte bármely operációs rendszer és eszköz számára lehet programot fejleszteni, illetve az egyszer elkészült program az itt felsorolt rendszerek bármelyikére lefordítható.

Természetesen nem minden processzor-operációs rendszer-adatbázis kezelő hármasra lehet fejleszteni, de a gyakorlatban előforduló kombinációk támogatottak.

FPC
FPC pillanatkép

A free Pascal oldalon terminal módban (szöveges módban) működő programok fejlesztéséhez egy FPC nevű , a windows jellegű „ablakos” programok készítéséhez Lazarus néven ajánlanak kezelőfelületet.  Harmadik gyártótól is szerezhető be kezelőfelület, ilyen például  az MSEide+MSEgui.

A Pascal egyszerűen tanulható, jól használható eszköz egyszerű programok készítésére. Az elkészült kód gyakorlatlan szemnek olvashatóbb, mint a C vagy C++ programok, ugyanakkor a kész program sokkal gyorsabban fut mint az interpreteres nyelveken (például BASIC, PERL) készült társaik.

Az elkészült program minőségét nagyban meghatározzák a kiválasztott beállítások. Minden ellenőrzés javítja a kész program üzembiztosságát,

Beállítások
Beállítások

azonban a futásidejét és a kész program méretét növeli és nem pótolja a gondos programozói munkát, de nagy mértékben segíti azt. Különösen a tanulási időszakban az ellenőrzések kikapcsolása nem célszerű, mivel a programhibák felderítést nehezíti, illetve a program üzembiztonságát rontja.
A különböző ellenőrzéseket ki/be kapcsolni az Options/Compiler.. menüben, vagy a programkódban elhelyezett direktívákkal lehet.

Range checking

A range checking jó példa arra, hogy a be és kikapcsolt állapotának is van létjogosultsága, attól függően, hogy az adott programrészletnek mi a célja, és azt hogyan szeretné elérni.

Megszámlálható típusoknál, illetve tömb indexeknél ellenőrzi, hogy a program futása során a változók értéke a megengedett értéktartományon belül marad-e, amennyiben nem, 201 számú hibával a program megáll. A Free Pascal esetén kifejezésenként, a Delphi esetén eljárásonként az itt beállított értéket a {$R+} illetve a {$R-} direktívákkal felül lehet írni a programban.

Egy példa:

Program Range;
Var
I:integer;
Begin
I:=maxint;
I:=I+1;
Writeln(I);
end.

A program kikapcsolt Range checking opcióval lefut és -32768 értéket ír ki. Míg bekapcsolt range checking esetén 201 hibával (range check errorr) a program végrehajtása megszakad.

Stack checking

A program által használt stack (verem) túlcsordulását figyeli. A program futása közben a {$S+} illetve a {$S-} direktívákkal lehet be illetve kikapcsolni. A stack túlcsordulása olyan súlyos hiba, hogy a program üzemszerű működését minden körülmények között megakasztja, a rendszer biztonságát veszélyeztető mellékhatásai miatt mindig bekapcsolva tartjuk . Mivel ha a stack túlcsordul, ismeretlen rendeltetésű memóriaterületet ír felül, ami rendszerösszeomláshoz vezethet, ritkán előforduló, azonban nehezen hibakereshető probléma.

I/O checking

I/O műveletnél végez alapvető ellenőrzéseket. Futásidőben a {$I+} és {$I-}  direktívákkal lehet ki és bekapcsolni, akár I/O műveletenként.  Bekapcsolt állapotban nyilvánvalóan hibás bemeneti adatok esetén (Szám helyett szöveg, az olvasandó fájl nem létezik) a program végrehajtása megszakad, kikapcsolt állapotban magunknak kell az ellenőrzéseket elvégezni. Mivel a legtöbb esetben a beérkező adatok ellenőrzése egyébként is szükséges, nem szoktuk bekapcsolni, illetve csak indokolt esetben.

Példa az I/O hibák kezelésére:

assign (f,’file.txt’);
{$I-}
rewrite (f);
{$I+}
if IOResult<>0 then
begin
Writeln (’Nem tudom megnyitni a  file.txt-t’);
exit
end;

A következő részben az optimalizációs lehetőségeket mutatom be egy egyszerű példaprogramon keresztül.

Az elsősorban a Pascal szintaxisának leírására használt szintaxisgráfokról Segesdy Gábor barátunk írt egy szép cikket.

Kapcsolódó cikkek