Delphi (programozási nyelv)

Az oldal jelenlegi verzióját még nem ellenőrizték tapasztalt közreműködők, és jelentősen eltérhet a 2020. január 8-án felülvizsgált verziótól ; az ellenőrzések 103 szerkesztést igényelnek .
Delphi
Nyelvóra kötelező , strukturált , objektumorientált , komponens orientált , magas szintű
Megjelent 1986  ( 1986 )
Szerző Anders Hejlsberg
Fájlkiterjesztés _ .pas, .dpr, .dpk, .pp, .dproj, .dfm, .fmx, .bpl
Kiadás Delphi 11.1 Alexandria [1]  (2022. március 15. ) ( 2022-03-15 )
Típusrendszer statikus , erős
Főbb megvalósítások Borland/Inprise/Codegear/Embarcadero Delphi ; Borland Kylix ; ingyenes pascal
Befolyásolva Object Pascal , C++
befolyásolta C# , Java [1]
Weboldal embarcadero.com/ru/produ…
Felület x86, x64, ARM
OS Windows , macOS , iOS , Android , Linux

A Delphi (Delphi, ejtsd: /ˈdɘlˌfi:/ [2] ) egy imperatív, strukturált , objektum-orientált , magas szintű programozási nyelv , amely a változók erős statikus tipizálásával rendelkezik. A fő felhasználási terület az alkalmazásszoftverek írása.

Ez a programozási nyelv az Object Pascal nyelv dialektusa . Az Object Pascal eredetileg egy kicsit más nyelvre utalt, amelyet 1986-ban az Apple -nél fejlesztett ki Larry Tesler csoportja [3] . A Delphi 7-től kezdve [4] azonban Borland fehér könyvei a Delphi nevet kezdték használni a korábban Object Pascal néven ismert nyelvre .

Célplatform

Kezdetben a Delphi fejlesztői környezetet kizárólag Microsoft Windows alkalmazások fejlesztésére szánták , majd egy Linux platformra való változatot valósítottak meg ( Kylix néven), azonban a Kylix 3 2002-es megjelenése után a fejlesztése leállt és a Microsoft támogatása Hamarosan bejelentették a .NET -et , amely viszont a Delphi 2007 megjelenésével megszűnt.

Jelenleg a 32 és 64 bites Windows-os programok fejlesztésének támogatása mellett lehetőség van Apple macOS -re (kezdve az Embarcadero Delphi XE2-vel), iOS - re (beleértve a szimulátort is, az XE4-től kezdve a saját fordítójával), Google Android (a Delphi XE5-től kezdve) [5] , valamint a Linux Server x64 (a Tokyo 10.2-es verziójától).

A fejlesztői környezet független, harmadik féltől származó megvalósítása a Lazarus projekt által ( Delphi kompatibilitási módban fordítva Free Pascal ) lehetővé teszi Delphi-alkalmazások létrehozását olyan platformokra, mint a Linux , a macOS és a Windows CE .

Voltak kísérletek a nyelv használatára GNU projektekben (pl . Notepad GNU ) és fordítóprogram írására a GCC számára ( GNU Pascal ).

IIS internetes szolgáltatások írására szolgál.

Filozófia és különbségek a népszerű alkalmazott programozási nyelvektől

A nyelv létrehozásakor (és itt a minőségi különbség a C nyelvhez képest) nem az volt a feladat, hogy a futtatható kód maximális teljesítményét, vagy a forráskód tömörségét biztosítsuk a RAM megtakarítása érdekében. Kezdetben a nyelv a harmóniára és a jó olvashatóságra helyezte a hangsúlyt, mivel a programozási fegyelem megtanítására szolgált. Ez a kezdeti karcsúság később, mind a hardver növekedésével, mind az új paradigmák megjelenése következtében megkönnyítette a nyelv új konstrukciókkal való bővítését.

Így a C++ objektum komplexitása a C-hez képest nagyon jelentősen megnőtt, és megnehezítette az első programozási nyelvként való tanulmányozását, ami az Object Pascalról nem mondható el Pascalhoz képest.

Az alábbiakban bemutatunk néhány különbséget a Delphi szintaxis konstrukciói és a C-szerű nyelvek családja (C/C++/Java/C#) között:

program Projekt32 ; {$APPTYPE CONSOLE} {$R *.res} rendszert használja . Sysutils ; begin try { TODO -oUser -cConsole Main: Kód beszúrása ide } kivéve az E : Exception do Writeln ( E . ClassName , ': ' , E . Message ) ; vége ; vége . A C-szerű programozási nyelvekben általában egy globális függvényt vagy statikus metódust használnak egy névvel mainés egy bizonyos paraméterlistával, és egy ilyen függvény a projekt bármely forrásfájljában megtalálható.
  • A Delphiben a típusok, változók és kulcsszavak azonosítói nem tesznek különbséget a kis- és nagybetűk között: például egy azonosító SomeVarteljesen egyenértékű a -val somevar. A számítógép-korszak kezdetén a kis- és nagybetűket megkülönböztető azonosítók felgyorsították a fordítási folyamatot, és lehetővé tették a nagyon rövid, esetenként csak kis- és nagybetűs elnevezések használatát is.
És bár mostanra mindkét gyakorlat - több azonosító használata, amelyek csak abban az esetben különböznek egymástól, valamint túlzott tömörségük - elítélték és nem ajánlottak, szinte az összes nyelv a C - C + nyelvből származik. A +, Java, C # - megkülönbözteti a kis- és nagybetűket , ami egyrészt elég nagy körültekintést igényel az azonosítók deklarálásában és használatában, másrészt szigorúbb kód írására kényszerít, ha minden változónak van egy jól definiált név (a kis- és nagybetűk eltérései zavart és hibákat okozhatnak).
  • A Delphiben a .pas forrásfájlokban (amelyek általában a program fő törzsét tartalmazzák) nyelvi szinten szigorú felosztást vezetnek be az interfész részre és az implementációs részre. Az interfész rész csak típus- és metódusdeklarációt tartalmaz, míg az interfész részben a megvalósítási kód fordítási szinten nem engedélyezett. Hasonló elválasztás a C / C ++ nyelvekre is jellemző, ahol a kultúra és programozás paradigma keretein belül a fejléc és a tényleges implementációs fájlok között elválasztást vezetnek be, de a nyelvnél vagy a fordítónál nincs ilyen elválasztás. szint.
A C#-ban és a Java-ban ez az elválasztás teljesen elveszett - a metódus megvalósítása általában közvetlenül a deklaráció után következik. A kapszulázást csak a módszer egyik vagy másik hatóköréhez való tartozása biztosítja. Speciális eszközöket használnak a forráskód modulnak csak az interfész részének megtekintéséhez.
  • A Delphiben a metódusokat vagy függvényeket egyértelműen a fenntartott kulcsszavak határozzák meg procedure, functionmíg a C-szerű nyelvekben a különbséget egy kulcsszó teszi, amely megadja a visszatérési érték típusát://Delphi eljárás DoSomething ( aParam : Integer ) ; //nem ad vissza értékfüggvényt Calculate ( aParam1 , aParam2 : Integer ) : Integer ; //egész eredményt ad vissza //C# void DoSomething ( int aParam ); // nem ad vissza értéket { // kód } int Calculate ( int aParam1 , aParam2 ); // egész számú eredményt ad vissza { // kód }
A C#/C++ nyelvben a nehezebbek az olyan konstrukciók, mint a „mutató a metódusra” típus deklarálása://C++: pCalc típusú deklaráció, egy tagfüggvényre mutató mutató, amely két egész paramétert vesz fel, és egy egész eredményt ad vissza typedef int ( TSomeClass ::* pCalc )( int , int ); A fenti példában a típusdeklaráció eltér a typedef kulcsszóval rendelkező változódeklarációtól, a típusnév, pCalc, a kifejezés közepén, zárójelben van megadva.//C#: pCalc típusú deklaráció, egy tagfüggvényre mutató mutató, amely két egész paramétert vesz fel, és egy egész eredményt ad vissza public delegate int pCalc ( int aParam1 , int aParam2 ); A fenti példában a típusdeklaráció eltér a változódeklarációtól egy speciális kulcsszóval delegate, a típusnév a kifejezés közepén van megadva.//Delphi típusú pCalc = függvény ( aParam1 , aParam2 : Integer ) : Objektum egész száma ; A fenti példában a típusdeklaráció eltér a változó deklarációjától speciális kulcsszóval type, egyenlőségjel használata (változó esetén kettőspont használatos), a típusnév közvetlenül a kulcsszó után következik.
  • A Delphiben a programblokk elejét és végét a és kulcsszavak jelölik begin, endmíg a C-szerű programozási nyelvekben a kapcsos zárójeleket használják erre a célra: {}. Így talán a Delphi jobb kódolvashatóságot ér el a látássérültek számára. Másrészt a göndör zárójelek vizuálisan intuitívabbak lehetnek, és piktogramként szolgálhatnak .//C# if ( bVal ) { // több utasításból álló kód } if ( bVal2 ) /* egy utasításból álló kód */ ;
A fenti példában a kapcsos kapcsos zárójelek összetett utasítást, azaz utasításblokkot jelölnek. Mivel a kapcsos kapcsos zárójel nélküli kifejezés egyetlen utasításhoz engedélyezett egy elágazási parancsban, a feltételes kifejezéseknél zárójelek szükségesek . Összetett feltételes kifejezésekben a beágyazott zárójelek száma nagy lehet.//Delphi if bVal then begin // többutasításos kód vége ; if bVal2 then (* egyetlen utasítás kódja *) ; A Delphiben a feltételes kifejezést mindig a kulcsszó választja el a következő utasítástól then, így nincs szükség a feltétel zárójelbe foglalására.
  • A C-szerű nyelvekben ehhez az elválasztáshoz a feltételes ciklus zárójelben van:while ( feltétel ) { // ciklus "előfeltétellel" // ciklustörzs }; do { // másik ciklus törzse } while ( feltétel2 ); // a ciklus vége egy "utófeltétellel", a törzs legalább egyszer végrehajtásra kerül
A Delphiben az előfeltételes és az utófeltételes ciklusok jobban különböznek egymástól: egy utófeltételes ciklus végét nehezebb összetéveszteni egy előfeltételes ciklus kezdetével . De néha egy ilyen megkülönböztetés zavart okozhat (emlékezni kell arra, hogy a kilépésiuntil feltétel a ciklusban van megadva ).while feltétel do begin //a ciklus folytatásának feltétele a while szót követő kifejezés igazsága, mint a C/C# //loop body end ; ismételje meg //ciklus eleje utófeltétellel //hurok törzse , amíg nem feltétel2 ; //az till szót követő kifejezés igazsága a ciklusból való EXIT feltétele, ellentétben a C/C#-val
  • A Delphiben a változóhoz való értékadás műveletét egy egyenlőségjellel ellátott kettőspont jelöli :=, amelyet a matematikai jelölésekből vettek át. A kettőspont nélküli egyenlőségjel egy egyenlőségteszt operátor, amely logikai értéket ad vissza. Ezzel szemben a C-szerű nyelvekben a hozzárendelési operátor egyetlen egyenlőségjel, az egyenlőségteszt operátor pedig egy kettős jel, ==. Tekintettel arra, hogy ezekben a programozási nyelvekben a hozzárendelés csak egy kifejezés, amely a bal oldali változó értékét adja vissza, a következő hibák, amelyek egy kezdő számára nem nyilvánvalóak, nem olyan ritkák:// C++ int iVal = 12 ; while ( iVal = 1 ) { // a programozó szándéka szerint ezt a ciklustörzset nem szabad végrehajtani, ha az iVal a bemeneten egytől eltérő értéket tartalmaz // azonban a == jel hibás egyetlen =-re cserélése következtében az iVal az 1 értéket adta, és a ciklus végtelen lesz }
Delphiben egy ilyen hiba nem lehetséges, már csak azért is, mert ezen a nyelven a hozzárendelés olyan művelet, amely nem ad vissza értéket.
  • A Delphiben az objektum- és objektumorientált programozás, bár javasolt, nem az egyetlen lehetséges megoldás. Tehát megengedett (a C#-tól eltérően) globális vagy statikus függvények és változók deklarálása és használata.
A C# nyelv objektummá kényszerül. Globális, osztályra való hivatkozás nélkül, a függvények tilosak. Az értéktípusok, akárcsak a structs struct, a C# általános típusától öröklődnek, annak ellenére, hogy önmagukban nem örökölhetők (vagyis a struktúra öröklődése nem megengedett a C#-ban). A C# osztályok példányai azonban implicit hivatkozási típusok, akárcsak a Delphiben. Mivel a Windows rendszerhívásai (mint a POSIX rendszerekben, mint például a Linux, a Mac OS) formálisan nem objektumok, a C # kód interakciója még akkor is nehézkes, ha figyelembe vesszük a változók memóriabeli élettartamának kezelésének eltérő paradigmáját. . A Delphinek nincsenek ilyen korlátozásai. Ennek az objektumközpontú paradigmának ellenére a C#-ból hiányzik a virtuális konstruktor fogalma, vagyis egy olyan osztály példányának létrehozása, amelynek pontos típusa nem ismert a fordítási időben, de csak az adott példány alaposztálya ismert. Ez a hátrány részben interfészekkel vagy tükrözéssel kompenzálható, de az ilyen megoldások nem szabványosak a nyelven.type TAnimal = osztály absztrakt védett FPersonalName : string ; public konstruktor Create ( const PersonalName : string ) ; virtuális ; absztrakt ; function GetSpecieName : string ; virtuális ; absztrakt ; // visszaadja az állattulajdonság biológiai faját Name : string read FPersonalName ; vége ; TAnimalClass = a TAnimal osztálya ; // metaosztály, amely bármely osztályra hivatkozhat, amely a TAnimal-ból öröklődik ... function CreateAnAnimal ( const FactAnimalClass : TAnimalClass ; const Név : string ) : TAnimal ; begin Eredmény := FactAnimalClass . Létrehoz ( név ) ; // a függvény nem tudja, hogy milyen állat jön létre, bár a "becenév" ismert. A nézet konkrét megvalósítása rejtett. vége ; Ezenkívül a C#-tól és C++-tól eltérően, ahol az alaposztály-konstruktor hívása szükségszerűen az örökölt osztálykonstruktor törzsébe való belépés előtt történik, a Delphiben ez a hívás kifejezetten megtörténik. Így speciális célokra elhalasztható vagy teljesen elhagyható. Nyilvánvalóan a C#-tól eltérően lehetséges a kivételek szabályozása az alapkonstruktorokban.
  • Az objektum-orientált megközelítés legrugalmasabb és leghatékonyabb megvalósítása érdekében a Delphi két polimorf hívási mechanizmust vezetett be: a klasszikus virtuális és a dinamikus : ha klasszikus virtuális hívás esetén az összes virtuális függvény címe szerepelni fog a virtuális metódusok táblázatában. minden osztályból, akkor dinamikus hívás esetén egy metódusra mutató mutató csak annak az osztálynak a táblájában létezik, amelyben azt definiáltuk vagy felülírták.
Így egy B-ben újradefiniált A osztály metódusának D osztályból történő dinamikus meghívásához meg kell keresni a D, A és B osztályok metódustábláit. Az optimalizálás célja a metódustáblák által elfoglalt statikus memória méretének csökkentése. A megtakarítás jelentős lehet hosszú osztályhierarchiák esetén, nagyon sok virtuális metódussal. A C-szerű nyelvekben dinamikus polimorf hívások nem használatosak.
  • A C#-tól eltérően a Delphi nyelv lehetővé teszi egy absztrakt (megvalósítással nem rendelkező) metódusokat tartalmazó osztály példányának létrehozását (inicializálását). Ahhoz, hogy kizárjuk egy osztály példányának létrehozását, nem elég absztrakt metódusokat deklarálni benne. Az absztrakt kulcsszót kell használni az osztálydeklarációban. Így jelenleg azok az osztályok, amelyek absztrakt metódusokkal rendelkeznek (ellentétben a korai Delphi implementációkkal), nem tekinthetők absztraktnak. A virtuális függvénymechanizmus segítségével egy absztrakt metódusokkal rendelkező alaposztály kódja futás közben meghatározza, hogy egy adott absztrakt metódus felülírásra kerül-e az osztály tényleges példányában, és ettől függően vagy meghívja a felülbírált metódust, vagy EAbstractError kivételt dob.
A Delphi lehetővé teszi egy alaposztály bármely konkrét virtuális metódusának felülbírálását egy leszármazott osztály absztrakt metódusával:típus TMyBase = osztály ( TObject ) függvény A : egész szám ; virtuális ; // Az A metódusnak van egy implementált törzse a megvalósítás végszakaszában ; TMyDerived = osztály ( TMyBase ) függvény A : egész szám ; felülbírálni ; absztrakt ; // a metódus absztraktként felülírva, nincs törzse, // és egyben felülírja (elrejti) az alaposztály végén megvalósítottat ; eljárás Teszt ; var m : TMyBase ; kezdődik m := TMyDerived . létrehozni ; // Létrehoztunk egy osztályt egy m absztrakt metódussal . A ; // az A hívása polimorf, és EAbstractError-t kapunk, amikor megpróbáljuk végrehajtani az absztrakt metódus end ;
  • A C++-tól eltérően a C# nyelv rendelkezik a Delphitől örökölt osztálytulajdonságok fogalmával: pszeudo-mezőkkel, amelyek bizonyos esetekben a metódusokhoz képest intuitívabban képesek tükrözni és megváltoztatni egy objektum állapotát.public class Dátum { //ez a példa a [http://msdn.microsoft.com/en-us/library/w86s7x04.aspx msdn] webhelyről származik. private int month = 7 ; // háttértár public int Hónap { get { return month ; } set { if (( érték > 0 ) && ( érték < 13 )) { hónap = érték ; } } //készlet } //prop } //osztály
A Delphi hasonló forráskódja így nézhet ki:type TDate = class private FMonth : Integer ; védett eljárás SetMonth ( const Érték : Integer ) ; // megvalósítás az implementációs részben public property Month : Integer read FMonth write SetMonth ; vége ; Mielőtt rátérnénk a tulajdonságok nyelvi megvalósításának összehasonlítására, megjegyezzük, hogy e két példa összehasonlítása egyértelműen azt mutatja, hogy a C # nyelv először is a göndör kapcsos zárójelekkel való visszaélést váltja ki (ami nem olyan ijesztő, tekintettel azok rövidségére. írás), másodszor pedig az egyes osztálytagok kupac kötelező hozzáférési specifikációi; Delphiben (mint a C++-ban), ha egy specifikátor deklarálva van, az minden további tagra vonatkozik. Illetve, ha Delphiben lehetőség van egy tulajdonságot mezőértékhez kötni, akkor a C#-ban mindig el vannak látva hozzáférő metódusokkal összetett parancszárók használatával (kivéve az automatikus tulajdonságokat). Ezek a metódusok a Delphitől eltérően nem deklarálhatók virtuálisak, és nem is hívhatók közvetlenül. Az accessor a C#-ban mindig egy és csak egy tulajdonságra utal, míg Delphiben ez az állítás általában nem igaz. Ezenkívül ugyanaz a módszer használható jelentősen eltérő tulajdonságokhoz való hozzáférés megvalósítására:típus TRectangle = privát osztály FKoordináták : Longint [ 0 .. 3 ] tömbje ; _ függvény GetCoordinate ( Index : Integer ) : Longint ; eljárás SetCoordinate ( Index : Integer ; Érték : Longint ) ; public property Balra : Longint index 0 olvasás GetCoordinate írás SetCoordinate ; tulajdonság Felül : Longint index 1 olvasás GetCoordinate írás SetCoordinate ; tulajdonjog : Longint index 2 olvasás GetCoordinate írás SetCoordinate ; _ tulajdonság Alul : Longint index 3 olvasás GetCoordinate írás SetCoordinate ; tulajdonság Koordináták [ Index : Integer ] : Longint olvasás GetCoordinate írás SetCoordinate ; vége ; Mind a Delphi, mind a C# lehetővé teszi az indexelt tulajdonságok használatát: ebben az esetben az ilyen tulajdonságok elérésének szintaxisa hasonló egy tömbelem eléréséhez. Míg azonban Delphiben az indexelt tulajdonságok, valamint az indexelők száma tetszőleges lehet, addig a C#-ban az indexelő csak egy speciális alapértelmezett tulajdonságra vonatkozik. Ezenkívül a Delphiben nem csak egy alapértelmezett tulajdonság lehet indexelhető, hanem egy indexelő típusa is túlterhelheti:TMyObject = osztály védett függvény getStr ( Név : string ) : string ; virtuális ; függvény getStrByIx ( Index : Integer ) : string ; virtuális ; függvény getBy2Indicies ( X , Y : Integer ) : string ; virtuális ; public property Érték [ Név : string ] : string read getStr ; alapértelmezett ; property Érték [ Index : Integer ] : string beolvasása getStrByIx ; alapértelmezett ; property Érték [ X , Y : Integer ] : string beolvasása getBy2Indicies ; alapértelmezett ; //szám vége ;
  • A Java és a C# nyelveket eredetileg arra tervezték, hogy olyan programokat írjanak, amelyek felügyelt környezetben futnak, ahol a környezet kezeli az objektumok élettartamát: így a kézi memóriakezelés nem megengedett. Ennek a megközelítésnek a kényelme és biztonsága negatív hatással van a teljesítményre.
A szemétszállítás előnyei és hátrányai

A .NET és a Java platformok nagyban leegyszerűsítették a programok fejlesztését egy "szemétgyűjtő" bevezetésével, amely lehetővé teszi a programozó számára, hogy ne aggódjon a futó programkód hatókörén kívül eső objektumok által elfoglalt memória felszabadítása miatt. Ez egyrészt jelentősen csökkentette az ún. „memóriaszivárgások” problémáját (amikor a címvesztés miatt amúgy is szükségtelen és elérhetetlen adatok foglalják el a RAM-ot), másrészt viszont szükség volt a platform egy összetett és erőforrás-igényes „szemétgyűjtési” algoritmus megvalósítására – amelyet hagyományosan úgy valósítanak meg, hogy megtalálják az elérhető objektumokat, és elengedik a többit. A gyakorlatban az objektumok elérhetőségének kimerítő elemzése érdekében a szemétgyűjtő bizonyos időpontokban felfüggeszti a programot (minden szálát), ami a válaszkészség rövid távú elvesztéséhez vezet. Az ilyen leállások gyakorisága és időtartama közvetlenül függ a rendelkezésre álló RAM mennyiségétől (amíg van szabad memória, a szemétgyűjtő igyekszik nem végezni blokkolási elemzést), valamint a programban részt vevő objektumok számától (így, jobb, ha van néhány "nagy" tárgy, mint sok - kicsi).

A helyzet a programba bevont szálak számának növekedésével romlik, mert a kimerítő elérhetőségi elemzés teljes leállítást igényel. Így a nyilvánvaló előny - a "memóriaszivárgás" problémájának megoldása és általában az objektumok élettartamának automatikus kezelése - a méretezés és a teljesítmény "hiba" implicit problémájához vezetett. Ez a probléma az egyszerű programokban finom, de a kódbázis összetettségének és méretének növekedésével egyre akutabbá válik - vagyis a fejlesztés végső szakaszában. Az összetett szoftverrendszerek általában valós idejű referencia- és reagálási követelményekkel rendelkeznek.

Pontosabban, ha a szemétgyűjtőnek 5-ször több memóriája van, mint amennyire szüksége van, akkor a teljesítménye megegyezik vagy valamivel jobb, mint a közvetlen memóriakezelés. A szemétgyűjtő teljesítménye azonban gyorsan romlik, ha kis csípővel kell dolgozni. 3 méretű szükséges memóriával átlagosan 17%-kal, 2 mérettel pedig 70%-kal lassabb. A szemétgyűjtő is hajlamosabb a lapozásra, ha a memória töredezettségmentes. Ilyen körülmények között az összes általunk tesztelt szemétgyűjtő egy nagyságrenddel lassabb, mint a közvetlen memóriakezelés.Drew Crawford – Miért lassúak a mobilwebes alkalmazások?

A szemétszállítás rezsi csökkentésére tett kísérletek a programozási stílus jelentős torzulásához vezethetnek [6] [7] .

A Delphiben nincs automatikus memóriakezelés: (a klasszikus nyelvi fordítóprogramokban) az osztálypéldányok manuálisan jönnek létre és törlődnek, míg egyes típusoknál - interfészek, karakterláncok és dinamikus tömbök - a referenciaszámláló mechanizmust használják. Általánosságban elmondható, hogy ezen megközelítések egyike sem garantálja a memóriaszivárgás hiányát, másrészt viszont a reszponzivitás problémája nem releváns, a memóriakezelés időráfordítása kicsi, és ami még fontosabb, nyilvánvaló. Ezenkívül szivárgás hiányában a felhasznált RAM teljes mennyisége jelentősen kevesebb, mint a szemétgyűjtőre támaszkodó hasonló alkalmazások.

A nyelv története

Az Object Pascal a Turbo Pascal nyelv fejlesztésének eredménye , amely viszont a Pascal nyelvből fejlődött ki . A Pascal egy teljesen procedurális nyelv volt , a Turbo Pascal az 5.5-ös verziótól kezdve objektum-orientált tulajdonságokat adott hozzá a Pascalhoz, és dinamikus adattípus azonosítást adott az Object Pascalhoz, amely képes volt hozzáférni az osztályok metaadataihoz (azaz osztályok és tagjaik leírásához) lefordított kód, más néven introspekció  – ezt a technológiát RTTI -nek nevezték el . Mivel minden osztály örökli a TObject alaposztály funkcióit, így bármely objektumra mutató mutató konvertálható azzá, ami után a ClassType metódus és a TypeInfo függvény használható, amely introspekciót biztosít.

Ezenkívül a C ++ Object Pascal megkülönböztető tulajdonsága, hogy az objektumok alapértelmezés szerint a dinamikus memóriában helyezkednek el. A TObject osztály NewInstance és FreeInstance virtuális metódusait azonban felülbírálhatja. Így abszolút bármely osztály teljesítheti a "vágyat", "ahol akarok - ott fogok feküdni". Ennek megfelelően szerveződik a "többhalomozás".

Az Object Pascal (Delphi) a Turbo Pascal [8] funkcionális kiterjesztésének eredménye .

A Delphi óriási hatással volt a .NET platform C# nyelvének koncepciójára . Számos eleme és koncepcionális megoldása beépült a C#-ba. Ennek egyik oka Anders Hejlsberg , a Delphi egyik vezető fejlesztőjének átigazolása a Borland Ltd.-től. a Microsoft Corp.-nál.

  • A 8-as verzió kizárólag a .NET platform számára képes bájtkód generálására. Ez az első olyan környezet, amely többnyelvű alkalmazások fejlesztésére összpontosít (csak .NET platformra);
  • A későbbi verziók (amelyeket a kiadás éve jelölnek meg, nem pedig a sorozatszámok, mint korábban) Win32 alkalmazásokat és bájtkódot is létrehozhatnak a .NET platformhoz.

A Delphi for .NET  egy Delphi fejlesztői környezet , valamint a Delphi (Object Pascal) nyelv, amely a .NET-hez való alkalmazások fejlesztésére összpontosít.

A teljes értékű Delphi .NET fejlesztői környezet első verziója a Delphi 8 volt. Ez csak .NET-hez tette lehetővé alkalmazások írását. A Delphi 2006 támogatja az MDA technológiát az ECO (Enterprise Core Objects) 3.0-s verziójával.

2006 márciusában a Borland úgy döntött, hogy leállítja a JBuilder , Delphi és C ++ Builder integrált fejlesztői környezetek további fejlesztését az irányzat veszteségessége miatt. A cég IDE szektorának eladását tervezték. A szabad szoftverek támogatóinak egy csoportja adománygyűjtést szervezett, hogy megvásárolja a fejlesztői környezet és a fordító jogait a Borlandtól [9] .

Ugyanezen év novemberében azonban úgy döntöttek, hogy nem adják el az IDE üzletágat. Ennek ellenére az IDE-termékek fejlesztését mostantól egy új cég – a CodeGear – fogja irányítani, amelyet teljes egészében a Borland pénzügyileg irányít majd.

2006 augusztusában a Borland kiadta a RAD Studio könnyű verzióját Turbo néven: Turbo Delphi (Win32-hez és .NET-hez), Turbo C#, Turbo C++.

2008 márciusában bejelentették a termékcsalád fejlesztésének végét.

2007 márciusában a CodeGear megörvendeztette a felhasználókat egy frissített Delphi 2007 for Win32 termékcsaláddal és egy teljesen új Delphi 2007 for PHP termékkel.

2007 júniusában a CodeGear bemutatta a jövőre vonatkozó terveit, azaz közzétette az úgynevezett útitervet [10] .

2008. augusztus 25-én az Embarcadero, a CodeGear új tulajdonosa sajtóközleményt tett közzé a Delphi for Win32 2009-hez [11] . A verzió számos újítást hozott a nyelvbe, például [12] :

  • Alapértelmezés szerint teljes Unicode támogatás a nyelv minden részén, VCL és RTL; az összes Windows API függvény hívásainak lecserélése Unicode megfelelőkre (azaz a MessageBox a MessageBoxW-t hívja, nem a MessageBoxA-t).
  • Általános típusok , ezek is generikusok .
  • Névtelen módszerek .
  • Új fordítói direktíva: $POINTERMATH [ON|OFF].
  • Az Exit függvény immár a függvény típusától függően paramétereket fogadhat el.

A 2011-ben kiadott Delphi XE2 Win64 fordítóval és keresztfordítással egészítette ki az Apple operációs rendszereit (MacOS X, iOS).

A 2013-ban kiadott Delphi XE5 alkalmazások kereszt-összeállítását biztosította ARM/Android eszközökhöz.

Fordítók

  • Az Embarcadero Delphi (korábban CodeGear Delphi és Borland Delphi) valószínűleg a legismertebb fordító, amely a Borland Pascal és a Turbo Pascal utódja . Használja a Win16 (Delphi 1), a Win32 (Delphi 2 és újabb), a Win64 (Delphi 16 (XE2) és újabb), valamint a .NET 1.x, 2.0 (Delphi 8, Delphi 2005-Delphi 2007). A .NET-támogatás ezt követően egy külön termékké vált, az úgynevezett (Delphi-kompatibilis) Oxygene néven .
  • A Free Pascal (FPC) egy ingyenes Object Pascal fordító , amely különféle Pascal dialektusokat támogat, beleértve a Turbo Pascalt (bizonyos kikötésekkel), a Delphit és a natív dialektusokat. Jelenleg az FPC képes kódot generálni x86 , x86-64 , PowerPC , SPARC és ARM processzorokhoz , valamint különféle operációs rendszerekhez, köztük Microsoft Windows , Linux , FreeBSD , Mac OS . Számos szoftverfejlesztő környezet létezik FPC-hez (az egyik leghíresebb képviselője a Lazarus ).
  • GNU Pascal (a GCC külön kifejlesztett verziója ). Nem célja a Delphi dialektusok sorozatának folytatása a Pascal részeként, de ennek ellenére tartalmazza a Borland Pascal kompatibilitási módot, és nagyon lassan alkalmazkodik a Delphi nyelvi komponensekhez. Nem alkalmas Delphi kódot tartalmazó nagy projektek fordítására, de a legtöbb operációs rendszer és architektúra támogatja.
  • Az Oxygene (korábbi nevén Chrome ) egy korlátozott Delphi-kompatibilis nyelvi fordító, amely integrálva van a Microsoft Visual Studio -ba . Ingyenes CLI parancssori fordítóként is elérhető . .NET-et és monoplatformokat használ. Korábban Embarcadero Delphi Prism márkanév alatt árulták.
  • A MIDletPascal  egy Delphi-szerű szintaxisú programozási nyelv és egy azonos nevű fordító, amely a forráskódot kompakt és gyors Java bájtkóddá alakítja .
  • A PocketStudio  egy Pascal-alapú IDE Palm OS - hez .
  • Virtual Pascal  – Ingyenes fordító és szöveges IDE Win32, OS/2 és Linux rendszerekhez. Abban az időben nagyon gyors és nagyon kompatibilis (a delphi 5 konstrukciók részben támogatottak). Külsőleg nagyon hasonlít a Borland Pascal 7 szöveges környezetére, bár például nincs vele kompatibilis grafika. A fejlesztés azonban 2004-ben véget ért, és a forráskód nem volt nyitva. Azóta az FPC sokkal tovább ment, és általában jobb programozáshoz. Mindazonáltal a VP továbbra is nagyon jó lehetőség a Borland Pascal még elavultabb verzióinak gyors cseréjére iskolai / intézeti használatra, mivel a Win32-ben natívan működik, probléma nélkül az orosz kódolásokkal.

A nyelv szintaxisa

A típusrendszer

A Delphi típusrendszere szigorú , statikus .

A támogatott típusok rövid listája

A következő adattípusok támogatottak :

  • egész szám, aláírt és előjel nélküli: Byte, Shortint, Word, Smallint, Cardinal, Integer, UInt64, Int64
  • felhasználó által definiált enum típusok
  • valós típusok Single, Double, Extended (csak x86-32, Win64 Extended = Double), öröklött Real48 típus, egész szám emulációs módban működik. A típus Currencyfix pontosságú valós.
  • vonalak. A típus string automatikusan lefoglalódik a memóriában a referenciaszámlálással és a Copy-On-Write paradigmával. A Delphi későbbi verzióiban a karakterek kétbájtosak, Unicode-kompatibilisek. Az AnsiString egy hasonló megvalósítás az egy bájt karakterszélességű karakterláncokhoz. Az ilyen karakterláncok információkat tartalmaznak a kódolásról a szolgáltatásmezőben. A korábbi verziókból származó Windows-fordítók olyan típussal rendelkeznek WideString, amely teljesen kompatibilis BSTRa komponensobjektum-modellben található típussal . Megengedett a 255 egybájtos karaktert meg nem haladó fix hosszúságú karakterláncok használata is. Primitív karakterlánctípusok engedélyezettek, C: stílus PCharésPWideChar
  • tömbök. Egydimenziós, többdimenziós fix hosszúságú, valamint hasonló dinamikus, referencia számlálással.
  • felsorolás típusú elemekből álló halmazok. Egy ilyen felsorolás maximális mérete 256 elem.
  • Bejegyzések . Strukturális (érték) típus öröklődési támogatás nélkül. A Delphi 2006-tól kezdve a beágyazás, a módszerek és a tulajdonságok támogatása hozzáadásra került. Kezelői túlterhelés. A Delphi 10.3 Rio-tól kezdve az íráshoz használható konstruktorok létrehozásának lehetősége is bekerült.
  • Osztályok és általános osztályok (generikusok). Implicit hivatkozási típus. Támogatja a beágyazást, az öröklődést, a polimorfizmust, beleértve a virtuális konstruktorokat, az attribútumokat, az osztályok általános paramétereit és az egyedi metódusokat, valamint a metódusok indexenkénti elosztását. Egy osztály egy vagy több interfészt implementálhat, beleértve közvetetten is, ha egy interfész megvalósítását egy tulajdonságra vagy mezőre delegálja. A többszörös öröklés nem támogatott.
  • Mutatók függvényekre és metódusokra, valamint névtelen függvényekre mutatók.
  • A típusok olyan metaosztályok , amelyek tartalmaznak egy mutatót az objektum típusára (de nem magára az objektumra). Főleg a virtuális konstruktorok és az automatikus szerializálás megvalósítására vezették be.
  • interfészek. COM-kompatibilis (a Windows fordítóprogramon), ugyanattól az elődtől örökölt. A többszörös öröklés nem támogatott.
  • Dispinterfaces, az IDispatch interfésszel való munkához késői kötési módban.
  • Változattípusok Variant ésOleVariant — típus dinamikus gépeléssel.
  • A Turbo Pascallal való kompatibilitás érdekében karbantartott régi objektumok. Az osztály példányaitól eltérően egy objektum lefoglalható a veremben vagy statikusan. .

Operátorok

Az operátorok listája szóközzel elválasztva::= + — * / div mod not and or with xor shl shr ^ = <> >= <= < > @ in is as

Az operátorok rövid listája
  • Aritmetika: + — * / div modÖsszeadás, kivonás, szorzás, osztás (ami valós eredményt ad), egész osztás, maradék kivonás.

A visszatérési típus különbséget tesz az egész szám osztási operátorok ( divés mod) és az operátor között /. Ez utóbbi egész és valós operandusokra egyaránt alkalmazva mindig valós típust eredményez. Az összeadás operátort +a karakterlánc összefűzésére is használják (amikor a beépített karakterlánctípusokat használják).

  • Bináris / logikai: not and or xorinverzió (negáció), "ÉS", "VAGY", kizárólagos "VAGY". A művelet típusa (bináris vagy logikai) az első operandus típusától függ.

Az egész típusú bitoperátorok közé tartoznak a shl, shr - shift operátorok is, amelyek jelentésükben megfelelnek az Intel x86 processzorok azonos nevű parancsainak.

  • Ordinális operátorok (összehasonlító operátorok) = <> > < >= <= – egyenlőségek, egyenlőtlenségek (a C-szerű nyelvekben az operátornak felel meg !=), nagyobb, mint, kisebb, nem kevesebb, nem több – minden ordinális és valós típusra vonatkoznak, és egy típusú értéket adnak visszaboolean
  • A halmaz operátorok közé tartozik az + - * in összeadás, a kivonás, a metszethalmaz és az előfordulási teszt operátor, amelyek a beépített halmaztípus manipulálására szolgálnak. Az első három a halmaz típusát, az utolsó a logikai típust adja vissza.
Példa az in operátor használatára type TDayOfWeek = ( hétfő , kedd , szerda , csütörtök , péntek , szombat , vasárnap ) ; //set enum type TDays = a TDayOfWeek halmaza ; //készlet típusa be van állítva var day : TDayOfWeek ; napok : TDays ; isMyDay : Boolean ; kezdőnapok : = [ vasárnap , kedd , szombat ] ; nap := hétfő ; isMyDay : = nap napokban ; // az in operátor egy logikai értéket ad vissza, első operandusnak egy "set element" típusú értéket, második operandusnak pedig egy "set" típusú end értéket vesz vissza ;
  • Típusöntési operátorok () as is – feltétel nélküli öntés, objektum- és interfésztípusok biztonságos öntése, valamint típustagsági teszt operátor (logiális értéket ad vissza). A feltétel nélküli (nem biztonságos) öntést funkcionális stílusban használjuk (a típusazonosítót a bal oldalon, a rá leadott kifejezést a jobb oldalon zárójelben írjuk), és alkalmazzuk az ordinális, valós, szerkezeti, hivatkozási, karakterlánc típusokra. Ugyanakkor a hivatkozási (beleértve az implicit hivatkozású) típusok esetében nincs tényleges leadás, hanem csak ugyanazon adatok új értelmezése.

A asés operátorok isolyan típusokra vonatkoznak, amelyek lehetővé teszik a polimorf viselkedést – osztálypéldányok és interfészek. Az első biztonságos (a félreértelmezés lehetetlensége értelmében) típuskonverziót eredményez, a második pedig valamilyen osztály vagy interfész osztályának vagy interfészének példányán keresztül teszteli a támogatást. Ne feledje, hogy a C#-tól eltérően az operátor hibás asöntése kivételt jelent.

  • Referencia operátorok ^ @ – mutatókkal való munkavégzésre szolgálnak.

Az operátor ^nem hivatkozik a mutatóra. Az operátor @az ellenkezőjét teszi, visszaadja a változó címét. Az egyszerű összeadás és kivonás a típusos mutatókon támogatott, a típusok méretétől függően ( intelligens mutató aritmetika).

  • Hozzárendelés operátor :=. A Delphiben a hozzárendelési operátor nem kifejezést, hanem műveletet alkot, így a hozzárendelések "karakterláncolása" nem megengedett.

Osztályok

Az Object Pascalban az osztályok speciális adattípusok, amelyeket az objektumok leírására használnak. Ennek megfelelően egy objektum, amelynek egy osztály típusa van, ennek az osztálynak egy példánya vagy egy ilyen típusú változó.

Az osztály egy speciális típus, amelynek olyan elemei vannak, mint a mezők, tulajdonságok és metódusok. Az osztálymezők hasonlóak a rekordmezőkhöz, és egy objektum információinak tárolására szolgálnak. A metódusok olyan eljárások és függvények, amelyeket általában mezők feldolgozására használnak. A tulajdonságok köztesek a mezők és módszerek között.

A nyelv objektumorientált jellemzői

Encapsulation

Az objektumadatok, valamint az azokat feldolgozó metódusok egy konkrét osztályon belüli kombinálását és elrejtését a felhasználó elől beágyazásnak nevezzük.

Öröklődés

Új objektumok létrehozásakor öröklődésnek nevezzük azt a képességet, hogy az összes tulajdonságot és metódust az őseiktől megkapják. Az ilyen objektumok létrehozásuk után örökölnek őseiktől minden mezőt, tulajdonságot, eseményt, módszert stb. Az öröklődés gyakran megkíméli a fejlesztőket a rutinmunkától, és lehetővé teszi számukra, hogy gyorsan nekifogjanak valami új fejlesztésének. A C++-tól eltérően a Delphi nem engedélyezi a többszörös öröklődést. A Delphiben lehetőség van egy osztályhoz vagy rekordhoz metódusokat hozzáadni az úgynevezett osztálysegítő vagy rekordsegéd (osztálysegítő vagy rekordsegéd) segítségével, amely nem lévén a módosítandó osztály vagy rekord leszármazottja, további metódusokat tud hozzáadni. nekik. Példa erre a System.SysUtils modulban deklarált TStringHelper helper bejegyzés.

Polimorfizmus

A Delphi az alkalmazott programozási nyelvekben elfogadott klasszikus polimorfizmus-modellt valósítja meg , amikor az alaposztályi metódusok, valamint az alaposztály típusú referenciaváltozók képesek manipulálni a leszármazott osztályok példányait az alaposztályban meghatározott szerződés alapján. A szerződés ebben az esetben az absztrakt metódusok deklarálása az alaposztályban.

Példák

Programstruktúra

Minden Delphi nyelven írt program egy programfejlécből (program NewApplication;), a használt modulok mezőjéből áll (például Uses Windows, Messages, SysUtils stb.), amelyek nem feltétlenül szerepelnek magában a szerkezetben, mivel valamint leírás blokkokat és végrehajtásokat (kezdődik összetett operátorral kezdődik és a végén a end.).

program Projekt1 ; // A program fejléce "Project1" névvel a Forms , Unit1 elemet használja a 'Unit1.pas' {Form1} -ben ; // a projekthez kapcsolódó és a program által használt modulok {$R *.res} kezdje el az alkalmazást . Inicializálja ; // Alkalmazás inicializálása Alkalmazás . CreateForm ( TForm1 , Form1 ) ; // Űrlap/ablak alkalmazás létrehozása . futni ; // Indítsa el és hajtsa végre end .

1. példa

A "Hello, world!" üzenet megjelenítése Delphi konzolalkalmazásban

program Helloworld ; //program neve {$APPTYPE CONSOLE} //irányító a fordítónak egy konzolalkalmazás létrehozásához begin writeln ( 'Hello, world!' ) ; //kimeneti üzenet Hello, world! readln ; //várja, amíg a felhasználó megnyom egy billentyűvéget . // program vége

2. példa

A "Hello, world!" üzenet megjelenítése egy 32 bites Delphi GUI alkalmazásban

... eljárás TForm1 . Button1Click ( Feladó : TObject ) ; //Az OnClick eseménykezelő automatikusan generált kezdődik ShowMessage ( 'Hello, world!' ) ; //kimeneti üzenet Hello, world! vége ; //eljárás vége ...

3. példa

A karakterláncok listájának dinamikus létrehozása és fájlba írása.

// Az űrlap létrehozásakor bekövetkező esemény kezelője MainForm eljárás TMainForm . FormCreate ( Feladó : TObject ) ; var // TStrings típusú változó deklarálása (karakterláncok listája). Strings : TStrings ; begin // TStringList típusú objektum létrehozása (memória lefoglalása és kezdeti értékekkel való feltöltése). // A TStringList a TStrings leszármazottja, amely absztrakt módszereit valósítja meg a karakterláncok memóriában való tárolására. Strings := TStringList . létrehozni ; próbálkozzon // Karakterlánc hozzáadása. Húrok . Add ( 'Hozzáadandó sor.' ) ; // Minden sor mentése fájlba. Húrok . SaveToFile ( 'C:\Strings.txt' ) ; végül // Az objektum memóriájának lefoglalása és hivatkozásának törlése, hogy megakadályozza a nem lefoglalt memóriához való véletlen hozzáférést. FreeAndNil ( Strings ) ; vége ; vége ;

Fájlkiterjesztések

  • .pas - modul forráskódja (pascal)
  • .dpr - projekt forráskódja (pascal)
  • .dproj - projekt forráskódja (xml)
  • .dproj.local - projekt forráskódja (xml)
  • .dfm - Forráskód formája
  • .dpk - csomag projekt forráskód
  • .bpl - összeállított csomag
  • .dcu - összeállított modul
  • .exe - összeállított pályázat
  • .res - erőforrások
  • .dsk - fájl hivatkozások
  • .identcache - gyorsítótárazott fájltársítások

Figyelemre méltó Delphi szoftver

A Delphiben írt számos általános szoftvertermék között megtalálható [13] :

Kritika

A nyelv kritikája a fejlődés korai szakaszában

A Pascal-kritika története 1981-ig és Brian Kernighan [15] munkásságáig nyúlik vissza , akinek érvei a nyelv fejlődésével többnyire elavultak.

Innovációk a mobil platformokon történő összeállításhoz

Az Embarcadero (nyelvi fejlesztő) által az úgynevezett Delphi NextGen fordítókban végrehajtott néhány nyelvi változtatás szándékosan megszakította a kompatibilitást a felhalmozott forráskódbázissal. Ezeket a változtatásokat a tapasztalt Delphi fejlesztők széles köre negatívan fogadta, mert bár közelebb hozták a nyelvet a .NET nyelvi paradigmához, megtörték a magas visszamenőleges kompatibilitás hagyományát, és jelentősen megnehezítették a meglévő forráskód szoftverre történő portolását. mobil platformokhoz. A következő változtatások megkérdőjelezték az Embarcadero által támogatott többplatformos, egyetlen forrású fejlesztés paradigmáját.

  • a karakterláncok nulla bázisú indexelésének bevezetése

A Pascal óta a beépített karakterlánctípust történelmileg 1-es bázissal indexelték: a karakterlánc "null" eleme visszaadta a karakterlánc hosszát. Az új („hosszú” és „unicode”) karakterlánc-típusok bevezetésével ez az indexelési sorrend megmaradt, így a kódbázis szinte zökkenőmentes hordozhatóságát biztosította a nyelv frissített verzióihoz. A nextgen fordítás bevezetésével azonban megváltozott a paradigma: az új fordítókban a karakterláncokat nulla bázissal kezdték indexelni, mint a C-szerű nyelvek családjában (C ++, C #, Java), míg a Windows és Mac OS "klasszikus" fordítóiban az egyszeri indexelés paradigmáját megmentették.

  • egy nem alternatív referenciaszámláló mechanizmus bevezetése osztálypéldányokhoz

Történelmileg az osztályok és példányaik implicit hivatkozású struktúratípusok. Az osztálypéldány élettartam-kezelése azonban eredetileg manuálisan történt - a konstruktor és a destruktor (vagy metódus Free()) explicit meghívásával, és ez a funkció megmarad (2018-tól) a fordítók klasszikus verzióiban. A referenciaszámlálás csak olyan osztályoknál működött, amelyek interfészeket valósítanak meg, és ráadásul csak abban az esetben, ha az ilyen osztályokat interfész típusú változókon keresztül manipulálták.

A 10.4-es verzió előtt a mobil platformok fordítói bevezették a referenciaszámlálást az osztályok minden példányára, ezzel alapjaiban változtatták meg az objektum élettartam-kezelés paradigmáját, mivel a "kézi" kezelés gyakorlatilag (néhány nagyon fejlett technikát leszámítva) nem kompatibilis az új paradigmával.

A 10.4-es verzió óta bevezették az egységes memóriakezelési mechanizmust [16] , amikor az objektummemória-kezelés klasszikus megvalósítását használják mobilra, asztali számítógépre és szerverre. Az ARC memóriakezelési modell megmaradt a karakterláncok és interfésztípus hivatkozások kezelésére minden platformon.

A nyelv lassú evolúciója azt jelenti, hogy

Sok fejlesztő úgy látja, hogy a Delphi konzervativizmusa olyan erény, amely rendkívül hordozhatóvá teszi a kódot, és megkönnyíti a nyelv megértését a kezdő programozók számára.

Jelenleg azonban olyan a helyzet, hogy szinte minden évben megjelennek (és egyre népszerűbbek) új technológiák, paradigmák, sőt programozási nyelvek is. A nyelvi eszközök fejlesztése nem mindig vonja maga után a visszafelé kompatibilitás elutasítását.

Ennek a megközelítésnek a kiváló példája az

egy megkésett bevezetés a lokális változók blokkon belüli deklarálásának nyelvébe

A fordító 33.0-s verziója (Delphi 10.3 Rio) előtt a lokális változó deklarációjának meg kellett előznie a függvénykód első utasítását, és a helyi (verem) változók inicializálása a deklarációs oldalon nem megengedett. A típuskövetkeztetés szintén lehetetlen volt.

Összehasonlításképpen, a lokális változó deklarálása a függvényben bárhol natívan támogatott C-ben, és szinte minden olyan nyelv örökölte, amely a C-szerű stílushoz ragaszkodott - C++, C#, Java stb.

Ennek a nyelvi funkciónak a Delphiben való bevezetéséről sokáig szó esett, de akkor még nem találkozott a nyelvfejlesztők megértésével.

Ugyanakkor a lokális változók blokkon belüli deklarálása, kivéve a For ciklus műveleteit, megnehezítheti a nagy projektek kódjának olvashatóságát.

Jegyzetek

  1. ↑ A RAD Studio 11.1 Alexandria elérhetőségi bejelentése . Archiválva az eredetiből 2022. április 20-án. Letöltve: 2022. április 12.
  2. ↑ A "del-phi" kiejtés dominál az Egyesült Királyságban: az Egyesült Királyságra jellemző kiejtési változat (angol) (elérhetetlen link) . Merriam-Webster online szótár . Merriam Webster. Letöltve: 2008. október 1. Az eredetiből archiválva : 2011. augusztus 21.. , az USA -ban pedig  - "del-fi": az Egyesült Államokra jellemző kiejtési változat (angol) (elérhetetlen link) . Merriam-Webster online szótár . Merriam Webster. Letöltve: 2008. október 1. Az eredetiből archiválva : 2011. augusztus 21..     
  3. ↑ David T. Craig. Apple Lisa Computer: Az Apple és a Pascal története .
  4. ↑ Delphi nyelvi áttekintése  (lefelé hivatkozás)
  5. ↑ közvetlenül végrehajtva az ARM processzoron )
  6. ↑ Dmitrij Ivanov – Mesék az idő előtti optimalizálásról a YouTube -on , 35:40-től
  7. ↑ Roman Elizarov – Idézetek milliói másodpercenként tiszta Java nyelven a YouTube -on , 58:59-től
  8. ↑ Ezt a fordítóverzió jelölései jelzik. Tehát a Delphi 7-ben a fordító verziószáma 15.0 (a Borland Pascal / Turbo Pascal legújabb verziója 7.0 volt, a Delphi 1-ben a fordító 8.0-s, a Delphi 2-ben - 9.0 stb. A 11.0-s verziószám a Pascal fordító, amely a C++ Builder környezet része volt ).
  9. ↑ Default Parallels Plesk Panel oldal archiválva 2006. december 5.
  10. ↑ Delphi és C++Builder ütemterv (lefelé irányuló kapcsolat) . Letöltve: 2007. július 18. Az eredetiből archiválva : 2007. október 10.. 
  11. ↑ Adatbáziseszközök és fejlesztői szoftver | Embarcadero Technologies (nem elérhető link) . Hozzáférés dátuma: 2008. augusztus 25. Az eredetiből archiválva : 2008. augusztus 29. 
  12. ↑ Delphi az Embarcaderotól | Az eredetiből archiválva : 2008. július 10. RAD alkalmazásfejlesztő szoftver
  13. ↑ Delphivel épített jó minőségű alkalmazások – Delphi programozás archiválva : 2011. június 30. a Wayback Machine -nél 
  14. ↑ MAXIMA elektronikus sorrendszer . mtg-biz.ru. Hozzáférés dátuma: 2017. január 5. Az eredetiből archiválva : 2017. január 6.
  15. ↑ Miért nem a Pascal a kedvenc programozási nyelvem ? Hozzáférés dátuma: 2016. május 23. Az eredetiből archiválva : 2009. április 28.
  16. ↑ A RAD Studio 10.4 újdonságai Sydney - RAD Studio - Termékek .features-tabs ul.nav.nav-tabs A RAD Studio 10.4 újdonságai A RAD Studio 10.4 jelentősen továbbfejlesztett, nagy teljesítményű natív Windows-támogatást, megnövekedett termelékenységet és  ragyogó hatást biztosít)  ? . Embarcadero webhely . Letöltve: 2020. szeptember 15. Az eredetiből archiválva : 2020. szeptember 16.

Irodalom

Linkek

 Pascal
Dialektusok
Fordítók
Kereskedelmi
Ingyenes
Nem támogatott
IDE
Személyek
 Programozási nyelvek