Pascal (ohjelmointikieli)

Kokeneet kirjoittajat eivät ole vielä tarkistaneet sivun nykyistä versiota, ja se voi poiketa merkittävästi 16. toukokuuta 2022 tarkistetusta versiosta . tarkastukset vaativat 3 muokkausta .
Pascal
Kieliluokka välttämätöntä , jäsenneltyä
Toteutustyyppi koottu
Esiintyi 1970
Tekijä Niklaus Wirth
Tiedostotunniste _ .paskooditiedostoille .inc, otsikkotiedostoille .
Vapauta ISO/IEC 10206:1991 Vaihe: 90.93 ( 29. heinäkuuta 2008 )
Tyyppijärjestelmä staattinen , vahva , turvallinen [1]
Tärkeimmät toteutukset CDC 6000 , ICT 1900 , Pascal-P , PDP-11 , PDP-10 , IBM System/370 , HP , Free Pascal , GNU , PascalABC.NET
Murteet UCSD , Turbo , Delphi
Vaikutettu ALGOL
vaikutti Modula-2 , Oberon , Component Pascal , Ada , Object Pascal , Java [2] [3] [4] , Oxygene
Verkkosivusto iso.org/standard/18237.h…
 Mediatiedostot Wikimedia Commonsissa

Pascal onyksi tunnetuimmista ohjelmointikielistä [  5 ] , jota käytetään ohjelmoinnin opetukseen lukiossa ja yliopistojen ensimmäisinä vuosina, ja se on perusta useille muille kielille.

Historia

Pascal-ohjelmointikieli luotiin vuonna 1970 Algol-60- kielellä [6] .

Pascalin loi Niklaus Wirth vuosina 1968-1969 osallistuttuaan Algol-68-kielistandardien kehittämiskomitean työhön . Kieli on nimetty ranskalaisen matemaatikon, fyysikon, kirjailijan ja filosofin Blaise Pascalin mukaan, joka loi yhden maailman ensimmäisistä mekaanisista koneista, joka lisää kaksi numeroa . Wirthin ensimmäinen kielijulkaisu on päivätty 1970; Kieltä esitellessä kirjoittaja asetti sen luomisen tavoitteeksi pienen ja tehokkaan kielen rakentamisen, joka edistää hyvää ohjelmointityyliä käyttämällä strukturoitua ohjelmointia ja strukturoitua dataa.

Wirthin myöhempi työ oli luoda Pascaliin perustuva järjestelmäohjelmointikieli säilyttäen samalla kyvyn suorittaa systemaattinen, kokonaisvaltainen ammatillinen ohjelmointikoulutus sen pohjalta: ” Ohjaava idea oli rakentaa Pascalille aito seuraaja, joka täyttää järjestelmäsuunnittelun vaatimukset. , mutta myös tyydyttääkseni opettajani halun esittää systemaattinen, johdonmukainen, houkutteleva ja opettavainen kehys ammattimaiselle ohjelmoinnille. ". Tämän työn tuloksena syntyi Modula-2- kieli , jonka jälkeen Wirth alkoi kehittää olio-ohjelmointikieltä Oberon perustuen kaikkeen aikaisempaan kehitykseen [6] .

Niklaus Wirth piti yhtenä Pascal-kielen luomisen tavoitteista opettamaan opiskelijoille rakenneohjelmointia. Tähän asti Pascalia pidettiin ansaitusti yhtenä parhaista kielistä ohjelmoinnin alkuopetukseen. Sen modernit modifikaatiot, kuten Object Pascal, ovat laajalti käytössä teollisessa ohjelmointissa (Delphi-ympäristö). Pascal-kielen syntaksin perusteella luotiin myös ohjelmoitavien logiikkaohjaimien ohjelmointikieli Structured Text (ST) tai Structured Control Language (SCL) .

1990-luvulle mennessä Pascalista oli tullut yksi maailman laajimmin käytetyistä algoritmiohjelmointikielistä. Johtavat ohjelmistokehittäjät julkaisivat säännöllisesti uusia versioita kääntäjästään tälle kielelle. Aikansa suositut kääntäjät: Turbo Pascal (kehittäjä Borland ), Microsoft Pascal Compiler, Quick Pascal, Pascal-2, Professional Pascal, USCD Pascal [7] .

Toteutukset ja murteet

Pascal-kielellä on monia toteutuksia [8] .

UCSD Pascal

Vuonna 1978 Kalifornian yliopistossa San Diegossa kehitettiin UCSD p-System , joka sisälsi Wirth-kääntäjän portin Pascal-kielestä kannettavaan p-koodiin , lähdekoodieditorin, tiedostojärjestelmän jne. [9 ] ja otti käyttöön myös huomattavan määrän Pascal-kielilaajennuksia, kuten moduuleja, muuttuvan pituisia merkkijonoja, käännösohjeita, I/O-virheiden käsittelyä, tiedostoihin viittaamista nimellä ja paljon muuta. Myöhemmin Pascal-kielen tärkeimmät toteutukset perustuivat tähän murteeseen.

ObjectPascal

Vuonna 1986 Apple kehitti Pascal - kieleen objektilaajennuksen , joka johti Object Pascaliin . Sen kehitti Larry Teslerin ryhmä , joka neuvotteli Niklaus Wirthin kanssa .

Turbo Pascal ja Object Pascal

Vuonna 1983 ilmestyi ensimmäinen versio Borlandin Turbo Pascal -integroidusta kehitysympäristöstä , joka perustuu samannimiseen Pascal-toteutukseen.

Vuonna 1989 Turbo Pascalin versioon 5.5 lisättiin objektikielen laajennus.

Uusin versio (7.0) on nimetty uudelleen Borland Pascaliksi.

Objektitilat lainattiin Applen Object Pascalista, ja Object Turbo Pascal 5.5:n ja Applen Object Pascalin välillä on hyvin vähän kielieroja.

Melkein samaan aikaan Borlandin kanssa Microsoft julkaisi versionsa Pascal-oliokielestä. [10] [11] Tätä Pascal-versiota ei käytetty laajalti.

Borlandin Pascal-toteutuksen jatkokehitys johti Borlandin Object Pascal -muunnelmaan, myöhemmin Delphi -ohjelmointiympäristön kehittämisen aikana , joka sai saman nimen .

Midlet Pascal

Object Pascalin nykyaikaiset versiot

Tärkeä askel kielen kehityksessä on ilmaisten Pascal-kielten Free Pascal- ja GNU Pascal -toteutusten syntyminen , jotka eivät vain omaksuneet monien muiden kielen murteiden ominaisuuksia, vaan myös varmistaneet siihen kirjoitettujen ohjelmien erittäin laajan siirrettävyyden. (esimerkiksi GNU Pascal tukee yli 20 eri alustaa, yli 10 eri käyttöjärjestelmässä, Free Pascal tarjoaa erityisiä yhteensopivuustiloja kielen useiden yleisten murteiden kanssa, kuten Turbo Pascal (täysi yhteensopivuus), Delphi ja muut).

Delphi 2003:sta lähtien .Net -alustalle on luotu kielitoteutus , vaikka kehittäjät käyttävät edelleen Delphiä aiemmista versioista.

Tällä hetkellä vain vähän tiedetään Free Pascalin, GNU Pascalin ja TMT Pascalin kaupallisesta kehityksestä.

Lisäksi Southern Federal University on kehittänyt PascalABC.NETin  , Pascal-ohjelmointikielen, joka sisältää suurimman osan Delphi -kielen ominaisuuksista sekä useita sen omia laajennuksia. Se perustuu Microsoft.NET -alustaan ​​ja sisältää lähes kaikki nykyaikaiset kieliominaisuudet: luokat , operaattorin ylikuormitus , rajapinnat , poikkeusten käsittely , yleiset luokat ja aliohjelmat , roskienkeruu , lambda -lausekkeet .

Kielen ominaisuudet

Kielen ominaisuuksia ovat tiukka kirjoittaminen ja rakenteellisten (menettelytapojen) ohjelmointityökalujen saatavuus . Pascal oli yksi ensimmäisistä tällaisista kielistä. Wirthin mukaan kielen tulisi edistää kurinalaista ohjelmointia, joten voimakkaan kirjoituksen ohella mahdolliset syntaktiset epäselvyydet minimoidaan Pascalissa ja kirjoittaja yritti tehdä itse syntaksista intuitiivisen jo kieleen tutustumisen yhteydessä.

Aluksi kielellä oli kuitenkin useita rajoituksia: mahdottomuus siirtää vaihtelevan pituisia matriiseja funktioille, normaalien dynaamisen muistin kanssa työskentelykeinojen puute , rajallinen I/O-kirjasto , keinojen puute yhdistää muihin kirjoitettuihin funktioihin. kielet, erillisten käännöstyökalujen puute jne. Yksityiskohtaisen analyysin tuon ajan Pascal-kielen puutteista teki Brian Kernighan artikkelissa "Miksi Pascal ei ole suosikkiohjelmointikieleni" [12] (tämä artikkeli ilmestyi 1980-luvun alussa, kun Modula-2 , Pascalin jälkeläinen, pääsi eroon suurimmasta osasta paheistaan ​​sekä kehittyneemmistä Pascalin murteista). Jotkut Pascalin puutteet korjattiin vuoden 1982 ISO-standardissa, erityisesti kieleen ilmestyi avoimia taulukoita, jotka mahdollistivat samojen menettelyjen käytön erikokoisten yksiulotteisten taulukoiden käsittelyssä.

Monet kielen puutteet eivät kuitenkaan esiinny ohjelmoinnin opettelussa tai niistä tulee edes etuja. Lisäksi verrattuna 1970-luvun akateemisen ympäristön pääohjelmointikieleen (joka oli Fortran , jolla oli paljon merkittävämpiä haittoja), Pascal edusti merkittävää edistysaskelta. 1980-luvulle mennessä Pascalista tuli perusta lukuisille koulutusohjelmille, joissakin tapauksissa sen pohjalta luotiin erikoistuneita ohjelmointikieliä, esimerkiksi 1980-luvun alussa Neuvostoliitossa Andrei Ershov kehitti Algol-Pascalin kaltaisen kielen. opettaa koululaisille tietojenkäsittelytieteen ja tietotekniikan perusteita. " algoritmisen kielen oppiminen ".

Tunnetuin Pascalin toteutus, joka varmisti kielen laajan levityksen ja kehityksen, on Borlandin Turbo Pascal , joka sitten kasvoi Object Pascaliksi DOS:lle (alkaen versiosta 5.5) ja Windowsille ja edelleen Delphiksi, jossa merkittävä kieli laajennuksia otettiin käyttöön.

Standardit

Pascalin käytön alkaessa vuonna 1970 ja toteutusten ilmaantumisen jälkeen, jotka erosivat paitsi lisäyksien, myös syntaksin suhteen, nousi esiin kysymys kielen standardoinnista. Kielistandardin kehitti Niklaus Wirth vuonna 1974 Kathleen Jensenin kanssa. [13] Myöhemmin otettiin käyttöön ISO:n kansainvälinen standardi ja ANSI:n amerikkalainen standardi. Tällä hetkellä on olemassa kolme pohjimmiltaan erilaista standardia: Unextended Pascal (alkuperäinen), Extended Pascal (laajennettu), Object-Oriented Extensions to Pascal (olio-Pascal-laajennus).

Pascal-kielistandardit: lähde, kansainvälinen ISO ja amerikkalainen ANSI
Nimi Vaihtoehto Kuka/missä kehittyi Luomisen vuosi
Pascal-standardi alkukirjain N. Wirth, Kathleen Jensen 1974
Pascal-standardi alkukirjain ISO 7185:1983
ANSI/ IEEE 770X3.97:1983		 1982
Jatkamaton Pascal alkukirjain ISO 7185:1990 1989
Laajennettu Pascal laajennettu ANSI/IEEE 770X3.160:1989 1989
ISO/ IEC 10206 1991
Olio-
laajennukset Pascaliin [14] 		oliosuuntautunut laajennus ANSI/X3-TR-13:1994 1993

Yksi oliosuuntautuneen Extended Pascal -laajennuksen tärkeimmistä lisäominaisuuksista oli modulaarisuus ja erillisen kääntämisen mahdollistavat toiminnot.

Kielen standardointi oli jäljessä tiettyjen ominaisuuksien todellisesta esiintymisestä kielessä. Kaupalliset toteutukset ovat laajentaneet Pascal-standardia; tämä on tehty UCSD Pascalissa, Applen Object Pascalissa , Borlandin Turbo Pascalissa (hieman muokattu versio Applesta) ja sen jälkeläisistä. Mikään Pascalin yleisimmistä kaupallisista toteutuksista ei ole täsmälleen yhdenkään virallisen kielistandardin mukainen.

Syntaksi- ja kielirakenteet

Pascal on alkuperäisessä muodossaan puhtaasti proseduurikieli ja sisältää monia Algol-tyyppisiä rakenteita ja varattuja sanarakenteita, kuten if, then, else, while, forjne repeat. Pascal sisältää kuitenkin myös suuren määrän mahdollisuuksia strukturoida tietoa ja abstraktioita, jotka puuttuvat alkuperäisestä Algol-60 :stä , kuten tyyppimäärittelyistä , tietueista , osoittimista , enumeista ja joukoista . Nämä rakenteet ovat osittain periytyneet tai inspiroituneet Simula -67:stä , Algol-68: sta luonut Niklaus Wirth AlgolWja ehdotti Hoare .

Nykyaikaisissa murteissa (Delphi Pascal, Free Pascal) on käytettävissä operaattorien ja toimintojen ylikuormitus.

Hei maailma!

Pascal-ohjelmat alkavat avainsanalla Program , jota seuraa ohjelman nimi ja sen jälkeen puolipiste (valinnainen joissakin murteissa), nimen perässä voi olla suluissa luettelo ulkoisista tiedostokuvauksista ("ympäristö") parametreina; sitä seuraa ohjelman runko, joka koostuu vakioita ( ), tyyppejä ( ), muuttujia ( ), proseduurien ( ) ja funktioita ( ) kuvaavista osista sekä niitä seuraavasta lausekelohkosta , joka on sisäänpääsy ohjelmoida. Pascalissa lohko on rajoitettu avainsanoihin ja . Lausunnot erotetaan puolipisteillä , jonka jälkeen rungon jälkeen on piste , joka toimii merkkinä ohjelman päättymisestä. ConstTypeVar ProcedureFunctionbeginend

Pascalin kirjainkoolla ei ole väliä .

Siten yksinkertaisin ("tyhjä") Pascal-ohjelma näyttäisi tältä:

ohjelma p ; alku loppu .

Yllä oleva ohjelma ei tee mitään ja sisältää tyhjän lausekkeen.

Esimerkki ohjelmasta, joka tulostaa merkkijonon " Hei, maailma!" »:

ohjelma hei ; alkaa writeln ( 'Hei, maailma!' ) ; // merkkijonon lähtöoperaattori loppua .

Tietotyypit

Yksinkertaiset tyypit

Tavallisessa ja laajennetussa Pascalissa on yksinkertaisia ​​tyyppejä: liukuluku ( real), kokonaisluvut ( integer), merkki ( char), boolean ( boolean) ja enumeraatiot (uusi tyyppinen konstruktori käyttöön Pascalissa).

Turbo Pascal on lisännyt kieleen tämäntyyppisiä muunnelmia: esimerkiksi shortintse on lyhyempi integerja longint pidempi.

Nykyaikaiset Pascalin murteet, kuten FPC tai Delphi , katsovat, että integer - tämä on tietylle koneelle sopivin kokonaisluku, jota käytetään esimerkiksi taulukon indekseille , ja shortintja longintmuille - tietyn pituisia kokonaislukuja; tämä on kätevä monialustaisessa ohjelmoinnissa. Samoin murtolukujen kanssa.

Tyyppejä laajennettiin jälleen x64 :ään vaihdettaessa  - "vain kokonaisluku" ( integer) pysyi 32-bittisenä, mutta vaadittiin erikoistyyppi, joka on yhtä suuri longintkuin x86 ja int64x64.

Kokonaislukutyypit:

Tyyppi Alue Muoto Koko tavuina Huomautuksia
tavua 0...255 allekirjoittamaton yksi
ShortInt −128...127 Ikoninen yksi
SmallInt −32768..32767 Ikoninen 2 Ei ehkä ole olemassa; sen sijaan kokonaisluku, jolla on sama alue
Sana 0..65535 allekirjoittamaton 2
pitkä sana 0..4294967295 allekirjoittamaton neljä
LongInt −2147483648..2147483647 Ikoninen neljä
int64 −9223372036854775808..9223372036854775807 Ikoninen kahdeksan
QWord 0..18446744073709551615 allekirjoittamaton kahdeksan
Kokonaisluku -32768..32767. Ikoninen 2 tai 4 Nopein kokonaisluku; SmallInt tai LongInt
kardinaali ? allekirjoittamaton ? Nopein kokonaisluku; yleensä LongWord
NativeInt ? Ikoninen ? Ottelut koneen rekisteriin; LongInt tai Int64
NativeUInt ? allekirjoittamaton ? Ottelut koneen rekisteriin; LongWord tai QWord

Liukulukuluvut:

Tyyppi Alue Merkitsevien numeroiden lukumäärä Koko tavuina Tuki
Todellinen alustasta riippuvainen ??? ??? Kaikki kääntäjät; nykyaikaisissa se vastaa yleensä Double
Todellinen 48 2.9E−39..1.7E38 11-12 6 Borland; Turbo Pascalissa sitä kutsuttiin Realiksi; ei käytä apuprosessoria ja siksi tulos toistetaan bitille
Yksittäinen 1.5E−45..3.4E38 7-8 neljä Useimmat vaihtoehdot IEEE 754 -yhteensopiville koneille
Kaksinkertainen 5.0E-324..1.7E308 15-16 kahdeksan Useimmat vaihtoehdot IEEE 754 -yhteensopiville koneille
Laajennettu 3.4E-4951..1.1E4932 19-20 kymmenen Useimmat vaihtoehdot x86:lle
Comp −9223372036854775808..9223372036854775807 kahdeksan Borland; apuprosessorilla laskettu 8-tavuinen kokonaisluku; relevantti 16-bittiselle x86:lle
Valuutta −922337203685477.5808..922337203685477.5807 kahdeksan Borland ja muut kääntäjät Windowsille; liittyy OLE :hen ; kiinteä piste , jonka yksikkö on 10 000
var {muuttujan ilmoitusosio} r : Todellinen ; {reaalityypin muuttuja} i : Kokonaisluku ; {kokonaislukutyypin muuttuja} c : Char ; { merkkimuuttuja } b : Boolen ; { boolen} s : Merkkijono ; { merkkijonomuuttuja } t : Teksti ; {muuttuja tekstitiedoston ilmoittamiseen} e : ( omena , päärynä , banaani , appelsiini , sitruuna ) ; { enum-tyyppinen muuttuja }

Pascalissa bittikohtaiset toiminnot ovat sallittuja kokonaislukutyypeille (tavu, shortint, sana, kokonaisluku, longint ja niiden alueet). Loogiset operaatiot biteille:

Kahden kokonaislukuoperandin biteillä voit suorittaa aiemmin harkitut loogiset toiminnot: not, ja, tai, xor. Ero bittikohtaisten ja loogisten operaatioiden välillä on se, että bittikohtaiset (bittikohtaiset) toiminnot suoritetaan operandien yksittäisille biteille, ei niiden arvolle desimaalimuodossa (yleensä).

Järjestystietotyyppien ( ordinaal ) käsite erottuu, ne sisältävät kokonaislukutyypit (merkitty ja etumerkitön), loogiset ( boolean), merkki ( char), luetellut tyypit ja aluetyypit.

Järjestystyypit määritellään kokonaisluvulla (koodilla), joka saadaan järjestysfunktiolla. Kaikki järjestystyypeille suoritetut toiminnot suoritetaan niiden koodeille.

Alueet sisältävät joukon muita järjestystyyppejä olevia arvoja:

var x : 1 .. 10 ; y : 'a' .. 'z' ; z : päärynä..oranssi ; _ _

Järjestystyypeille on määritelty operaatiot inc, dec, succ, pred, ordvertailuoperaatiot ( = > < => <= <>), joita voidaan käyttää operaattoreissa case, for(silmukkalaskurina), taulukon rajojena määrittämään joukkojen ja aluetyyppien elementtejä.

Pascalissa, toisin kuin C:n kaltaisissa kielissä, kokonaislukuaritmeettisia operaatioita ei määritellä booleantyypeillä char.

Sarjat

Toisin kuin monet yleiset kielet, Pascal tukee erityistä joukkotietotyyppiä :

var set1 : joukko 1 .. 10 ; _ set2 : joukko ' a' .. 'z' ; set3 : päärynäsarja ..oranssi ; _ _ _

Joukko on modernin matematiikan peruskäsite, jota voidaan käyttää monissa algoritmeissa.

Pascalissa joukkotyyppi voi sisältää vain saman tyyppisen järjestystyypin elementtejä. Tämä ominaisuus on laajalti käytetty ja yleensä nopeampi kuin vastaava rakenne kielellä, joka ei tue joukkoja. Esimerkiksi useimmille Pascal-kääntäjille:

if i in [ 5 .. 10 ] then { tarkistetaan kuuluuko elementti joukkoon } ...

käsitellään nopeammin kuin

jos ( i >= 5 ) ja ( i <= 10 ) sitten { boolen testi } ...

Asettaaksesi joukon arvon, käytetään luetteloa joukon elementeistä, erotettuna pilkuilla ja suljettuina hakasulkeissa (kuten edellä on jo esitetty):

var {muuttujan ilmoitusosio } d : merkkijoukko ; alkaa { lohkon alku } d := [ 'a' , 'b' ] ; ...

Jensenin ja Wirthin Pascalissa merkkijonot esitettiin pakattuina merkkijonoina; siksi niillä oli kiinteä pituus ja ne oli yleensä pehmustettu tähän pituuteen välilyönneillä.

Komposiittityypit

Uusia tyyppejä voidaan määrittää olemassa olevista:

type { type Declaration section } x = Kokonaisluku ; y = x ; ...

Lisäksi yhdistelmätyyppejä voidaan rakentaa primitiivityypeistä:

tyyppi { tyypin ilmoitusosio } a = Kokonaisluvun taulukko [ 1..10 ] ; { taulukon määritelmä } b = tietue { tietueen määritelmä } x : Kokonaisluku ; y : Char ; loppu ; c = Tiedosto ; _ _ { tiedoston määritelmä }

Pascalin tiedostotyypit jaetaan kirjoitettuihin, teksti- ja tiedostotyyppeihin.

Kuten yllä olevassa esimerkissä näkyy, Pascalissa kirjoitetut tiedostot ovat samantyyppisten elementtien sarjoja. Jokaiselle tiedostolle on puskurin osoitinmuuttuja, joka on merkitty f^. Toimenpiteet get(lukemista varten) ja put(kirjoitusta varten) siirtävät osoittimen seuraavaan elementtiin. Lukeminen on toteutettu siten, että read(f, x)se on sama kuin get(f); x:=f^. Vastaavasti tietue on toteutettu siten, että write(f, x)se on sama kuin f^ := x; put(f). Tekstitiedostot textmääritellään file of chartyyppipäätteeksi, ja ne sallivat kirjoitettujen tiedostojen standarditoimintojen (lukeminen, merkin kirjoittaminen) lisäksi merkkien syöttämisen/tulostuksen kaikentyyppisten tietojen tiedostoon, samalla tavalla kuin konsolin syöttö/tulostus.

Tiedostot, joissa ei ole tyyppejä, ilmoitetaan tyypin muuttujina file. Niiden avulla voit suorittaa puskurin kautta tavu-tavuittain kirjoittamattomia I / O-operaatioita useille tietyn pituisille tavulohkoille. Tätä varten käytetään erityisiä menettelyjä blockreadja blockwrite(UCSD-laajennus).

Strings

Nykyaikainen Pascal [15] käyttää sisäänrakennettua tyyppiä string, joka tukee ketjutusta ( +) ja vertailua ( > < = <> >= <=), työskennelläkseen merkkijonojen kanssa. Merkkijonoja verrataan leksikografisessa järjestyksessä . Esimerkiksi merkkijonoja pidetään samanarvoisina, jos niillä on sama pituus ja kaikkien samalla indeksillä olevien merkkien koodit täsmäävät.

Tyyppi string [n]tai yksinkertaisesti string1970-1990-luvun kielen murteissa määriteltiin merkkijonoksi array [0..n] of char(n oletuksena otti arvon 80 UCSD Pascalissa ja 255 Turbo / Borland Pascalissa), taulukon nollaelementti tässä. esitys auttaa asettamaan merkkijonon pituuden, vastaavasti merkkijonon enimmäiskoko voi olla 255 merkkiä. Oletusarvoisesti Delphissä ja FreePascalissa AnsiString-tyyppiä käytetään merkkijonona, jonka muistin kääntäjä varaa ja vapauttaa dynaamisesti, ja suurin merkkijonokoko nykyisissä toteutuksissa on 2 gigatavua. Lisäksi Delphissä ja Free Pascalissa UnicodeString-tyyppiä voidaan käyttää tyyppinä, jossa käytetään 16-bittistä merkkien esitystapaa UCS-2-string koodauksessa , kun taas yksitavuisista merkkijonoista ei ole mahdollista muuntaa monitavuisiksi merkkijonoiksi. ja takaisin FPC-standardikirjastoon, mutta ne ovat saatavilla Delphissä.

Delphi 2009:ssä ja sitä uudemmissa versioissa on rakenne AnsiStringin ilmoittamiseksi tietyllä koodisivulla:

tyyppi CyrillicString = AnsiString ( 1251 ) ; CP866String = AnsiString ( 20866 ) ; Osoittimet

Pascal tukee osoittimien käyttöä (kirjoitettu ^типja kirjoittamaton pointer):

kirjoita a = ^ b ; b = tietue x : Kokonaisluku ; y : Char ; z : a ; loppu ; var pointer_to_b : a ;

Tässä muuttuja pointer_to_b on osoitin tietotyyppiin b, joka on tietue. Kirjoitettu osoitin voidaan määrittää ( katselu ) ennen sen tyypin ilmoitusta, johon se viittaa. Tämä on yksi poikkeuksista sääntöön , jonka mukaan mikä tahansa elementti (vakio, tyyppi, muuttuja, menettely, funktio) on ilmoitettava ennen käyttöä . Tämän poikkeuksen käyttöönoton avulla voit järjestää toistuvia tietorakenteiden määritelmiä, mukaan lukien lineaariset luettelot , pinot , jonot , puut, mukaan lukien osoitin merkintään tämän merkinnän kuvauksessa (katso myös: null pointer - nil).

Kirjoitetulle osoittimelle määritetään viittauksen poistotoiminto (sen syntaksi on: указатель^).

Uuden tietueen luomiseksi ja arvon 10ja symbolin määrittämiseksi Akenttiin xja ysiinä vaaditaan seuraavat lausunnot:

uusi ( osoitin_b ) ; { muistin varaus osoittimelle } pointer_to_b ^. x := 10 ; { osoittimen viittauksen poistaminen ja tietuekentän käyttö } pointer_to_b ^. y := 'A' ; pointer_to_b ^. z : = nolla ... hävittää ( osoitin_b ) ; { muistin vapauttaminen osoittimen alta }

Voit myös käyttää operaattoria viitataksesi tietueiden ja objektien kenttiin with, kuten esimerkissä näkyy:

uusi ( osoitin_b ) ; jossa pointer_to_b ^ aloita x : = 10 ; y := 'A' ; z := nolla loppu ; ... hävittää ( osoitin_b ) ; Proseduurityyppi

Pascal Jensenin ja Wirthin alkuperäisessä kielessä proseduurityyppiä käytettiin vain muodollista parametria kuvattaessa. TP:ssä oli jo täydellinen menettelytyyppi . Tyyppiselvitys sisältää proseduurin tai funktion otsikon (ilman nimeä), joka kuvaa yleisesti aliohjelman käyttöliittymää. Tämän tyyppinen arvo sisältää osoittimen aliohjelmaan, jonka otsikko vastaa tyyppimäärityksessä ilmoitettua otsikkoa. Muuttujan tunnistetta voidaan käyttää kutsumaan sopiva proseduuri tai funktio.

Aliohjelmaesimerkki Pascalille kirjoita myfunc = funktio : merkkijono ; func1 : merkkijono ; _ begin func1 := 'toiminto #1' end ; func2 : merkkijono _ _ begin func2 := 'toiminto #2' end ; var fun : my func ; aloita hauskanpito :=@ func1 ; writeln ( hauska ) {func1-funktiota kutsutaan} end .

Valvontalausekkeet

Pascal on strukturoitu ohjelmointikieli , mikä tarkoittaa, että ohjelma koostuu erillisistä vakiokäskyistä, jotka suoritetaan peräkkäin, mieluiten ilman komentoa GOTO.

Esimerkki Pascalille while a <> b do { silmukan edellytyksellä } writeln ( 'Odottaa' ) ; if a > b then { ehdollinen lauseke } writeln ( 'Ehto täyttyy' ) else { else-section - voidaan jättää pois} writeln ( 'Ehto epäonnistui' ) ; for i := 1 - 10 do { iteraatiosilmukka } writeln ( 'Iteraatio #' , i : 1 ) ; for i in [ 1 .. 10 ] tee { iteroi joukon läpi } writeln ( 'Iteraatio #' , i : 1 ) ; { ilmestyi versiossa 2.4.0 } with a do {Operaattori With - menetelmä nopeuttaa pääsyä tietuekentille} begin l := 1 ; k := 2 ; p :=- 3 ; loppu ; toista { jälkiehtosilmukka } a := a + 1 kunnes a = 10 ; {ehdollisen monivalintaoperaattorin} tapaus i 0 : kirjoittaa ( ' nolla' ) ; 1 : kirjoittaa ( 'yksi' ) ; 2 : kirjoittaa ( 'kaksi' ) else write ( 'tuntematon numero' ) { else-section - voidaan jättää pois} end ;

Lausumissa while, for, lohkoaif voidaan casekäyttää suoritettavana käskynä . Tällaista konstruktiota, joka on tavallinen lause tai lohko, kutsutaan kompleksilauseeksi .

Turbo Pascalissa on käännösprosessin ohjaamiseksi kommentteihin sijoitetut käskyt, joiden avulla voit vaihtaa kääntäjän toimintatiloja - esimerkiksi ottaa käyttöön ja poistaa käytöstä I / O-toimintojen tarkistukset, ylivuodot:

Esimerkki Pascalille assign ( inp , 'teksti.txt' ) ; {$I-} { poista IO-tarkistustila käytöstä - ohjelman poistumiskoodin luominen I/O-virheen sattuessa } { (jos tiedostoa ei löydy)} reset ( inp ) ; {$I+} { ota IO-tarkistustila käyttöön } if IOresult = 0 then begin { tarkista muuttujan ioresult arvo(<>0 I/O-virheen sattuessa) } ... close ( inp ) ; end else writeln ( 'tiedostoa ei löydy' )

On olemassa samanlaisia ​​direktiivejä kuin C/C++ esiprosessoridirektiivit ( $ifdef, $define, $include), kääntäjä käsittelee ne kääntämisen aikana.

Menettelyt ja toiminnot

Pascalissa aliohjelmat on jaettu toimintoihin ja toimintoihin. Samaan aikaan funktiot eksplisiittisesti palauttavat tietyn tyyppisen arvon (tuloksen), eivätkä prosessit eksplisiittisesti palauta mitään.

Syntaktisesti proseduurin tai funktion kuvaus koostuu otsikosta , joka sisältää avainsanan proceduretai functionnimen, jota voi seurata suluissa annettujen (muodollisten) parametrien kuvaus. :Funktiolle palautusarvon tyyppi ilmoitetaan kaksoispisteellä . Otsikko päättyy puolipisteeseen ;. Otsikon jälkeen tulee runko , joka sisältää (mahdollisesti) paikallisten vakioiden, tyyppien, muuttujien, menettelyjen, funktioiden kuvausosat ja (pakollinen) lauselohkon, jota seuraa puolipiste ;.

Esimerkkiohjelma Pascalille ohjelmoi ( lähtö ) ; _ var i : kokonaisluku ; menettely tulosta ( var j : kokonaisluku ) ; funktio next ( k : kokonaisluku ) : kokonaisluku ; aloita seuraava := k + 1 loppu ; begin writeln ( 'Yhteensä: ' , j ) ; j := seuraava ( j ) loppu ; aloita i := 1 ; kun i < = 10 tulostaa ( i ) loppuun .

Proseduurin runko, kuten ohjelma, voi puolestaan ​​sisältää kuvauksia menettelyistä ja toiminnoista. Siten proseduurit ja funktiot voidaan upottaa toisiinsa niin syvälle kuin halutaan, kun taas ohjelman runko on ketjun ylimpänä.

Lisäksi sen sisällä on ennen menettelyn/funktion kuvausta olevien muuttujien, tyyppien, vakioiden, ulkoisen rungon (proseduurit, funktiot, ohjelmat) kuvauksen osioiden sisältö. Useimmissa murteissa voit myös käyttää ulkoisen proseduurin parametreja proseduurista.

Proseduurien/funktioiden otsikon jälkeen rungon sijaan voidaan sijoittaa avainsana forward, tämä tehdään, jos toimenpiteen/funktion kuvaus sijaitsee ohjelmassa sen kutsun jälkeen ja liittyy mahdollisuuteen kääntää ohjelma yksi pass tuettu Pascalissa.

Pascalin vakiomatemaattiset funktiot ja -menettelyt Matemaattiset funktiot
Toiminnon nimi Argumentin tyyppi Arvon tyyppi Laskennan tulos
Vatsalihas(x) koko todellista koko todellista "x":n itseisarvo
synti(x) todellinen todellinen sini "x" rad.
Cos(x) todellinen todellinen kosini "x" rad.
Arctan(x) todellinen todellinen "x":n arkitangentti ( -Pi/2 <y< Pi/2 )
sqrt(x) todellinen todellinen x:n neliöjuuri
sqr(x) koko todellista koko todellista "x":n arvo neliöitynä ( x 2 )
teho(a, x) todellinen todellinen "a":n arvo potenssiin "x" ( a x )
exp(x) todellinen todellinen "e":n arvo "x":n potenssiin ( e x , missä e= 2,718282... )
Ln(x) todellinen todellinen "x":n luonnollinen logaritmi (x > 0 )
frac(x) todellinen todellinen murto-osa "x"
Int(x) todellinen todellinen kokonaislukuosa "x"
Satunnainen - todellinen satunnaisluku ( 0 <=y< 1)
Satunnainen(x) Sana Sana satunnaisluku ( 0 <=y< x )
Succ(c) järjestysluku järjestysluku merkkiä "s" jälkeen
pred(c) järjestysluku järjestysluku edeltävä "with" merkki
Matemaattiset menettelyt
Toiminnon nimi Argumentin tyyppi Arvon tyyppi Laskennan tulos
Inc(x) koko koko Suurentaa "x" 1:llä (x:=x+1; )
Joulu(x) koko koko Pienentää "x":llä 1 (x:=x-1; )
Sisältö(x, n) koko koko "x" n:llä (x:=x+n; )
dec(x, n) koko koko "x" n:llä (x:=xn; )
Muuttujan tyypin muunnosmenettelyt
Toiminnon nimi Argumentin tyyppi Arvon tyyppi Laskennan tulos
Str(x, s) x-kokonaisluku tai todellinen s-merkkijono Merkkijono "s" luvun "x" numeroista
Val(t, v, turska) s-merkkijono v-kokonaisluku tai todellinen cod-kokonaisluku Järjestysnumeron "s" binäärimuoto cod=0 (virhekoodi)
Muuttujan tyypin muunnosfunktiot
Toiminnon nimi Argumentin tyyppi Arvon tyyppi Laskennan tulos
Trunc(x) todellinen LongInt kokonaislukuosa "x"
Kierros (x) todellinen LongInt pyöristää "x" kokonaisluvuksi
Pariton(x) koko looginen palauttaa True, jos "x" on pariton luku
Chr(x) tavua Hiiltyä ASCII-koodimerkki "x"
Järjestys(x) Hiiltyä tavua ASCII-merkkikoodi "x"

Moduulit

Ennen yhdistettyjen moduulien tuloa nykyaikaiseen muotoonsa jotkin Pascalin toteutukset tukivat modulaarisuutta otsikkotiedostojen sisällyttämismekanismin vuoksi, samanlainen kuin C-kielen mekanismi #include: käyttämällä erityistä pseudokommentiksi muotoiltua direktiiviä, esimerkiksi {$INCLUDE "файл"}, määritetyn tiedoston sisältö sisällytettiin suoraan ohjelman lähdekoodiin. , tekstimuodossa. Siten ohjelmakoodi oli mahdollista jakaa useisiin fragmentteihin editoinnin helpottamiseksi, mutta ennen kääntämistä ne yhdistettiin automaattisesti yhdeksi ohjelmatiedostoksi, jonka kääntäjä lopulta käsitteli. Tämä modulaarisuuden toteutus on primitiivinen ja siinä on monia ilmeisiä puutteita, joten se vaihdettiin nopeasti.

Nykyaikaiset Pascal-toteutukset (alkaen UCSD Pascalista) tukimoduulit. Ohjelmamoduuleita voi olla kahta tyyppiä: pääohjelmamoduuli, joka tavalliseen tapaan alkaa avainsanalla ohjelma ja jonka runko sisältää koodia, joka ajetaan sen jälkeen, kun ohjelma on ladattu muistiin, ja apumoduulit, jotka sisältävät tyyppejä, vakioita, muuttujia, toimenpiteitä ja toiminnot, jotka on tarkoitettu käytettäviksi muissa moduuleissa, mukaan lukien päämoduuli.

Rakenne

Pascalin laajennuksen yleinen rakenne on seuraava:

yksikkö YksikönNimi1 ; käyttöliittymä ... toteutus ... begin {voidaan jättää pois - käytetään, jos alustuskäskyt on asetettava} ... end .

Toinen vaihtoehto on myös mahdollinen:

yksikkö YksikönNimi2 ; käyttöliittymä ... toteutus ... alustus ... viimeistely .... loppua .

Toisin kuin pääohjelma, moduulitiedosto alkaa avainsanalla UNIT, jota seuraa moduulin nimi ja puolipiste. Nykyaikaiset toteutukset vaativat yleensä, että moduulin nimi on sama kuin moduulin sisältävän lähdekooditiedoston nimi. Moduuli sisältää kolme osaa: käyttöliittymäosion, toteutusosan ja moduulin rungon.

Käyttöliittymäosio tulee ensin, alkaa avainsanalla INTERFACEja päättyy moduulin kohtaan, josta toteutusosio tai runko alkaa. Liitäntäosio ilmoittaa ne objektit (tyypit, vakiot, muuttujat, proseduurit ja funktiot - niille sijoitetaan otsikot), joiden on oltava saatavilla moduulin ulkopuolelta. Tässä tapauksessa tyyppien osittainen ilmoittaminen on sallittua: ne voidaan ilmoittaa ilman rakennetta, vain yhdellä nimellä. Käytettäessä tätä tyyppiä ulkoisessa ohjelmassa on sallittua ilmoittaa tämän tyyppisiä muuttujia ja parametreja, antaa arvoja, mutta sen toteutuksen yksityiskohtiin ei pääse käsiksi. Proseduurit ja funktiot rajapintaosassa on ilmoitettu eteenpäin - otsikoina parametrein, mutta ilman runkoa. Moduulin liitäntäosan kokoonpano on sellainen, että se riittää generoimaan tätä moduulia käyttävän koodin. Liitäntäosassa ilmoitetut muuttujat ovat globaaleja, eli ne ovat olemassa yhdessä esiintymässä ja ovat käytettävissä kaikissa tätä moduulia käyttävissä ohjelman osissa.

Toteutusosio seuraa käyttöliittymäosiota ja alkaa avainsanalla IMPLEMENTATION. Se sisältää kuvaukset rajapintaosiossa määritellyistä proseduureista ja funktioista sekä kuvaukset tyypeistä, vakioista, muuttujista, proseduureista ja funktioista, jotka ovat välttämättömiä rajapintaproseduurien ja toimintojen toteuttamiseksi. Rajapintaosiossa ilmoitetun menettelyn tai toiminnon kuvauksen tulee olla täsmälleen sama otsikko kuin ilmoituksessa. Runko voi käyttää muita tämän moduulin proseduureja ja toimintoja, jotka on ilmoitettu sekä käyttöliittymäosassa että toteutusosiossa. Toteutusosiossa ilmoitetut muuttujat ovat itse asiassa globaaleja (eli jokaista tällaista muuttujaa on vain yksi esiintymä koko ohjelmassa), mutta niihin pääsee käsiksi vain tämän moduulin toteutusosiossa kuvatuista menettelyistä ja toiminnoista. sekä kehostaan. Jos käyttöliittymäosiossa on lyhennettyjä tyyppimäärityksiä, nämä tyypit on ilmoitettava täydellisesti toteutusosiossa.

Moduulin runko alkaa avainsanalla sisäkkäisyyden ylimmällä tasolla BEGIN. Runko sisältää ohjelmakoodin, joka suoritetaan kerran, kun moduuli ladataan. Runkoa voidaan käyttää alustukseen, alkuarvojen määrittämiseen moduulimuuttujille, resurssien allokointiin sen toimintaa varten ja niin edelleen. Moduulin runko saattaa puuttua. Monissa Pascal-toteutuksissa, esimerkiksi Delphissä, voidaan käyttää kahta osiota (myös valinnainen) moduulirungon sijasta - INITIALIZATIONja FINALIZATION. Ne sijoitetaan moduulin loppuun vastaavan avainsanan jälkeen. Ensimmäinen, alustusosio, sisältää koodin, joka on suoritettava, kun moduuli ladataan, ja toinen, viimeistely-osio, sisältää koodin, joka suoritetaan, kun moduuli puretaan. Viimeistelyosio voi suorittaa toimintoja, peruuttaa alustuksia - poistaa objekteja muistista, sulkea tiedostoja, vapauttaa varatut resurssit.

ENDModuuli päättyy piste- avainsanaan .

Käyttö

Moduulin käyttöä varten pääohjelman tai muun moduulin on tuotava moduuli eli sisällettävä ilmoitus sen käytöstä. Tämä ilmoitus tehdään module include -lauseella, joka on avainsana USESja sen jälkeen pilkuilla eroteltu sisällytettävien moduulien nimi. Kytkentäohjeen tulee välittömästi seurata ohjelman otsikkoa tai avainsanan jälkeen, INTERFACEjos yhteys tehdään moduulissa.

Liitäntäosaan kytkettyjä moduuleja voidaan käyttää koko moduulissa - sekä toteutusosassa että rungossa. Toteutusosalla voi kuitenkin olla oma include-käsky (se seuraa avainsanaa IMPLEMENTATION), joka sisältää niiden laajennusten nimet, jotka eivät ole käyttöliittymäosiossa, mutta joita toteutusosio tarvitsee. Eräs syy käyttää erillistä yhteysluetteloa toteutusosassa on se, että kaksi tai useampi moduuli käyttää toisiaan. Jotta vältytään pyöreiltä viittauksilta tällaisten moduulien käyttöselosteissa, vähintään yhden niistä tulee sisällyttää toinen toteutusosaan.

Mitä tahansa moduulien liitäntäosissa ilmoitettuja objekteja voidaan käyttää ohjelmassa, johon nämä moduulit on kytketty. Laajennuksista tuotujen objektien nimet pysyvät samoina ja niitä voidaan käyttää suoraan. Jos kahdessa tai useammassa yhdistetyssä moduulissa on objekteja, joilla on sama nimi, eikä kääntäjä pysty erottamaan niitä toisistaan, silloin kun yritetään käyttää tällaista objektia, syntyy käännösvirhe - epäselvä nimimääritys. Tässä tapauksessa ohjelmoijan tulee hakea nimen pätevyyttä - määritä nimi muodossa "<moduulin_nimi>.<objektin_nimi>".

Ongelmia voi syntyä, jos ohjelmassa on tarvetta käyttää kahta samannimistä moduulia. Jos moduulit ovat saatavilla vain käännetyssä muodossa (eli niiden nimiä ei voi muuttaa), niitä on mahdotonta tuoda samanaikaisesti. Kielitasolla tällaiseen törmäykseen ei ole olemassa standardiratkaisua, mutta tietyt kääntäjät voivat tarjota yhden tai toisen tavan ohittaa se, erityisesti keinoja antaa aliaksia tuoduille moduuleille ja määrittää suoraan, mikä moduuli mistä tiedostosta otetaan.

Kääntäminen ja linkittäminen

Moduulit on suunniteltu erikseen käännettäväksi - kääntäjän ei tarvitse kääntää tuotuja moduuleja kääntääkseen niitä käyttävän moduulin. Kääntääkseen moduulin oikein kääntäjällä on kuitenkin oltava pääsy kaikkien käyttämiensä moduulien liitäntäosaan. Tällaisen pääsyn järjestämiseen on kaksi erilaista, joskus yhdistettyä lähestymistapaa.

  • Moduulit käännetään erikoismuotoisiksi binääritiedostoiksi (jokaisella kääntäjällä omat), jotka tallentavat yksityiskohtaista tietoa käyttöliittymäosiossa ilmoitetuista objekteista ja voivat sisältää myös moduulin käännöksen aikana luodun objektikielen, mutta se käyttää vain rajapintaosaa. moduulista. Jos kirjastomoduuli toimitetaan käännetyssä muodossa (ilman täydellisiä lähdetekstejä), niin binaaritiedoston mukana on moduulin lähdekoodin katkaistu tiedosto, joka sisältää vain käyttöliittymäosan. Tämä riittää, jotta kääntäjä käsittelee oikein käyttävien moduulien puhelut, ja ohjelman käännösvaiheessa linkkeri yksinkertaisesti sisällyttää binaaritiedoston ohjelmaan.
Moduulien lataus ja purkaminen

Moduulin normaalia toimintaa varten saattaa olla tarpeen suorittaa joitakin toimia ennen sen käyttöä: alustaa muuttujat, avata tarvittavat tiedostot, varata muistia tai muita resursseja. Kaikki tämä voidaan tehdä moduulin rungossa tai alustusosiossa. Käänteinen alustus tehdään viimeistelyosassa.

Moduulien alustus- ja viimeistelyjärjestys määräytyy epäsuorasti käyttöosion ilmoitusjärjestyksen mukaan, mutta staattisesti käännetyille ohjelmille (joissa moduuli on joko käännetty yhdeksi suoritettavaksi tiedostoksi pääohjelman kanssa tai se sijaitsee erillisessä dynaamisessa kirjastossa, mutta ladattu alkulatausvaiheessa), kääntäjä takaa aina, että alustus tehdään ennen moduulin ensimmäistä käyttöä. Viimeistely tehdään ohjelman päättyessä päämoduulin päätyttyä, jolloin käytetyt moduulit viimeistellään myöhemmin kuin niitä käyttävät.

Ohjelmoijan itsensä ohjaamien moduulien dynaamisen lataamisen tapauksessa alustajat suoritetaan latauksen yhteydessä, eli sillä hetkellä, kun moduulin latauskomento palautti ohjauksen, sen alustus on jo suoritettu. Viimeistely suoritetaan purkamisen jälkeen, yleensä kun moduulin purkauskomento suoritetaan. Jos tätä komentoa ei kutsuta, dynaamisesti ladatut moduulit viimeistellään samalla tavalla kuin kaikki muutkin moduulit - ohjelman päättyessä.

Olio-ohjelmointi

Object Pascalilla on kyky kehittää ohjelmia käyttäen olio-ohjelmointiparadigmaa . Luokat määritellään käyttämällä objectsamantyyppistä tyyppiä record, joka voi sisältää tietokenttien lisäksi proseduuri- ja metodiotsikot . Kuvattujen menetelmien nimet seuraavat luokan nimeä pisteellä erotettuna.

Rakentaja ja tuhoaja määritetään tavallisiksi proseduureiksi, mutta tunnisteen sijaan määritetäänavainsanatprocedureja. Vastaavasti, toisin kuin C++- kaltaisilla kielillä, niillä on eri nimi kuin luokan nimi, tuhoajia voi olla useita ja niillä voi olla parametreja (käytännössä tätä ominaisuutta käytetään harvoin, yleensä luokassa on yksi tuhoaja, joka ohittaa virtuaalisen vanhemman luokan tuhoaja). constructordestructorDestroy

Yksittäinen periytyminen, luokkapolymorfismi , virtuaalinen menetelmämekanismi (sana virtualluokan jälkeen -metodin otsikko) ovat tuettuja. On myös dynaamisia menetelmiä (TP:ssä niitä kuvataan lisäämällä sanan perään kokonaisluku virtualja niitä käytetään pääasiassa viestien käsittelyyn; Delphissä ja FreePascalissa sanaa käytetään näihin tarkoituksiin messageja sanaa käytetään tavallisten dynaamisten menetelmien luomiseen dynamic) , jotka erottuvat pienemmästä muistinkäytöstä ja alhaisemmasta puhelunopeudesta, koska esivanhempien dynaamisten menetelmien kopiointi puuttuu lapsen VMT:ssä (FreePascal ei kuitenkaan tee eroa virtuaalisten ja dynaamisten menetelmien välillä).

Delphissä FPC toteutti operaattorin ylikuormituksen , abstrakteja menetelmiä, direktiivejä private, protected, public, published(oletuksena luokan jäsenet ovat public):

Esimerkkiohjelma Pascalille tyyppi TbasicO = objektiproseduuri writeByte ( b : tavu ) ; _ virtuaalinen ; abstrakti ; loppu ; TtextO = objekti ( TbasicO ) { perii TbasicO:n, toteuttaa muita kirjoitustavuihin perustuvia tulostustoimintoja } -proseduuri writeS ( s : string ) ; {..} loppu ; TfileO = objekti ( TbasicO ) {tiedoston tulostusluokka - toteuttaa tulosteen tavun tulostamisena tiedostoon} konstruktori init ( n : merkkijono ) ; menettely writeByte ( b : tavu ) ; virtuaalinen ; destructor closefile ; yksityinen f : tavun tiedosto ; _ loppu ; perusO = ^ TbasicO ; textO = ^ TtextO ; fileO = ^ TfileO ; rakentaja TfileO . init ( n : merkkijono ) ; alkaa määrittää ( f , n ) ; kirjoittaa uudelleen ( f ) loppu ; tuhoaja TfileO . closefile ; alkaa sulkea ( f ) loppu ; menettely TfileO . writeByte ( b : tavu ) ; alkaa kirjoittaa ( f , b ) loppu ; menettely TtextO . writeS ( s : merkkijono ) ; var i : kokonaisluku ; alkaa for i := 1 pituuteen ( t ) do writeByte ( ord ( s [ i ] ) ) end ; {..} var f : fileO ; alkaa uusi ( f , init ( 'tstobj.txt' )) ; {varaa objektille muistin ja kutsuu konstruktoria} textO ( f ) ^. writeS ( 'tekstijono' ) ; dispose ( f , closefile ) {kutsuttaa destructorin ja vapauttaa objektin muistin} end .

Delphi-murteessa luokat voidaan rakentaa myös sanalla class(lisäksi keskinäinen periytyminen -luokkien kanssa objectei ole sallittua) ja käyttöön otetaan liitännät ( interface) - kaikki menetelmät ovat abstrakteja eivätkä voi sisältää tietokenttiä.

Kaikki luokat (luodut classsovelluksella) perivät TObjectosoitteesta, kaikki liitännät ovat peräisin IUnknown. Luokat, jotka on luotu käyttämällä, classvoivat toteuttaa useita rajapintoja.

Delphissä otettiin käyttöön liitännät tukemaan Microsoftin COM -tekniikkaa.

Luokat ( Class) toisin kuin tavalliset luokat ( Object) eivät tarvitse nimenomaista muistin varausta/poistoa, niiden muisti varataan dynaamisesti konstruktorilla nimellä Create, kutsutaan luokan nimellä ja vapautetaan, kun destruktoria, jolla on nimi, kutsutaan Destroy(he voi olla muitakin nimiä). Tällaisen luokan muuttuja, toisin kuin luokka, objecttallentaa luokan esiintymän osoitteen muistiin, arvoa nilkäytetään ilmaisemaan tyhjää viittausta, joten objektin vapauttamiseksi määritellään TObjecterityinen menetelmä free, joka tarkistaa viittauksen nilja kutsuu virtuaalista tuhoajaa Destroy. Tällaisia ​​luokkia käyttävä koodi näyttäisi tältä:

Esimerkki Pascalille q1 := t1 . luoda ( 9 ) ; { rakentaa objekti(t1 - luokan nimi) } writeln ( q1 . InstanceSize ) ; { luokan esiintymän koon näyttäminen } q1 . Ilmainen ; { objektin tuhoaminen } q1 := nolla ; { jotta destructoria ei kutsuta uudelleen, kun free kutsutaan}

ObjectPascal/Delphi/FreePascal-modifikaatiossa luokkien kuvaukseen ilmestyvät ominaisuudet (ominaisuus), joissa yhdistyvät muuttujien (jonka roolia OOP:ssa ovat kentät) kanssa työskentelyn mukavuus ja menetelmäkutsut, jotka aina ilmoittavat objektille tilan muutos:

Esimerkkiohjelma Pascalille tyyppi TMyObj = luokka ( TObject ) FProp : kokonaisluku ; menettely SetProp ( arvo : kokonaisluku ) ; ominaisuus MyProp : kokonaisluku lue FProp kirjoittaa SetProp ; loppu ; menettely TMyObj . SetProp ( arvo : kokonaisluku ) ; aloita FProp := AValue ; Writeln ( 'Joku on vaihtanut MyProp!' ) ; loppu ; var MyObj : TMyObj ; begin MyObj := TMyObj . luoda ; OmaObj . FProp := 5 ; OmaObj . MyProp := OmaObj . MyProp + 6 ; loppua .

Ensimmäisessä tapauksessa (käyttäen MyObj.FPropa) kohteen kenttää on muutettu suoraan, minkä seurauksena objektin menetelmät eivät epäile, että tätä kenttää on muutettu aiemmin; monimutkaisemmassa tapauksessa he voivat luottaa siihen, että kenttä on muuttumaton, tai kentälle voidaan antaa arvo, joka ei kelpaa annetulle objektille. Toisessa tapauksessa arvo annetaan suoraan objektin ominaisuudelle, mikä viittaa menetelmäkutsuun, joka käsittelee oikein annetun kentän muuttamisen.

Tämä lähestymistapa on kätevä, jos objekti on liitetty visuaaliseen elementtiin: esimerkiksi elementin leveydestä vastaavan kentän muuttaminen suoraan ei vaikuta visuaaliseen elementtiin itseensä ja objekti saa "väärätietoa" todellisesta koosta. elementistä. Oikea lähestymistapa ilman ominaisuuksia on kehittää menetelmiä minkä tahansa kentän arvon saamiseen ja asettamiseen, mutta tällaisten menetelmien käyttäminen on vähemmän kätevää, esimerkiksi viimeisen rivin sijasta pitäisi kirjoittaa

OmaObj . SetProp ( MyObj . GetProp + 6 ) ;

Lisäksi MyObj.GetProp-menetelmä olisi pitänyt kirjoittaa yhdistämään pääsy.

Erittäin kiinnostavia ovat indeksiominaisuudet, jotka käyttäytyvät paljolti samalla tavalla kuin taulukot ja korvaavat pääsyn taulukkoelementtiin kutsulla vastaavaan menetelmään.

Ominaisuudet eivät kuitenkaan ole "ihme": käännettäessä ominaisuuskutsut käännetään suoraan menetelmäkutsuiksi tai suoraan kenttien kanssa, joten ominaisuudet eivät ole todellisia muuttujia, etenkään niitä ei voida välittää var-parametreina.

Muistiinpanot

  1. ↑ Kim B. Bruce. Oliokielten perusteet: tyypit ja semantiikka . - MIT Press, 2002-01-01. - S. 9. - 416 s. — ISBN 9780262025232 . Arkistoitu 18. kesäkuuta 2016 Wayback Machineen
  2. ↑ Valkoinen kirja. Tietoja Microsoftin "Delegatesista" Arkistoitu 27. kesäkuuta 2012 Wayback Machineen , java.sun.com
  3. ↑ Java-historia, Java-sovelluspalvelinraportti arkistoitu 29. joulukuuta 2010. TechMetrix Research, 1999
  4. ↑ Keskustelu James Goslingin kanssa . Haettu 16. lokakuuta 2009. Arkistoitu alkuperäisestä 16. heinäkuuta 2015.
  5. ↑ TIOBE-ohjelmointikielen suosioindeksi arkistoitu 25. joulukuuta 2018 Wayback Machinessa 
  6. ↑ 1 2 Wirth, N. Modula-2 ja Oberon // HOPL III  : Kolmannen ohjelmointikielten historiaa käsittelevän ACM SIGPLAN -konferenssin julkaisut: [ eng. ]  : [ arch. 22. joulukuuta 2012 ]. - ACM, 2007. - Kesäkuu. - s. 3-1-3-10. - doi : 10.1145/1238844.1238847 .
  7. ↑ Borodich, Yu. S. Esipuhe // Pascal henkilökohtaisille tietokoneille: viite. korvaus / Yu. S. Borodich, A. N. Valvachev, A. I. Kuzmich. - Mn.  : Higher School, 1991. - S. 3. - 365 s. : sairas. - BBK  32.973-01ya2 . - UDC  681.3.06 (035.5) . — ISBN 5-339-00662-X .
  8. ↑ Liste compilateur Pascal - Pascal - kääntäjäluettelo . Haettu 19. tammikuuta 2021. Arkistoitu alkuperäisestä 11. huhtikuuta 2021.
  9. ↑ Wirth N. Muistoja Pascalin kehityksestä (HOPL II), 3.3 . Haettu 16. huhtikuuta 2011. Arkistoitu alkuperäisestä 22. joulukuuta 2012.
  10. ↑ Jon Udell, Crash of the Object-Oriented Pascals, BYTE, heinäkuu 1989.
  11. ↑ MI Trofimov, The End of Pascal?, BYTE, maaliskuu, 1990, s. 36.
  12. ↑ Miksi Pascal ei ole suosikkiohjelmointikieleni . Käyttöpäivä: 27. elokuuta 2004. Arkistoitu alkuperäisestä 28. huhtikuuta 2009.
  13. ↑ PASCAL: Käyttöopas ja raportti ISO Pascal -standardi Kathleen Jensen ja Niklaus Wirth, 4. painos, Springer Verlag New York, Inc. 1974, 1985, 1991
  14. ↑ Pascalin olio-laajennukset arkistoitu 5. kesäkuuta 2021 Wayback Machinessa , tekninen komitea X3J9, ohjelmointikieli Pascal
  15. ↑ ISO 7185 Pascal . Haettu 12. huhtikuuta 2009. Arkistoitu alkuperäisestä 25. marraskuuta 2006.

Kirjallisuus

  • Wirth N. Algoritmit + tietorakenteet = ohjelmat. — M .: Mir , 1985. — 406 s.
  • Wirth N., Jensen C. Pascal. Käyttöopas ja kielikuvaus. — M .: Talous ja tilastot , 1982. — 151 s.
  • Grogono P. Ohjelmointi Pascalilla. — M .: Mir , 1982. — 384 s.
  • Kultin NB Delphi 6. Ohjelmointi Object Pascalilla. - Pietari. : BHV-Petersburg , 2001. - 528 s. — ISBN 5-94157-112-7 .
  • Morgun A. N. Ohjelmointi Pascalilla. Tietorakenteiden käsittelyn perusteet. - M . : Dialektiikka , 2005. - 576 s. — ISBN 5-8459-0935-X .
  • Perminov O. N. Ohjelmointikieli Pascal: Käsikirja. - M . : Radio ja viestintä , 1989. - 128 s. — ISBN 5-256-00311-9 .
  • Rubenking NJ Turbo Pascal for Windows: 2 osassa. Per. englannista. - M .: Mir, 1993.
  • Ohjelmointikielet Ada, C, Pascal = Ohjelmointikielten Ada, C ja Pascal vertailu ja arviointi / A. Feuer, N. Jehani. - M . : Radio ja viestintä, 1989. - 368 s. – 50 000 kappaletta.  — ISBN 5-256-00309-7 .
Standardit

Linkit

  Siirry Wikidata-kohteeseen  Sanakirjat ja tietosanakirjat
Bibliografisissa luetteloissa
 Pascal
Murteet
Kääntäjät
kaupallinen
Vapaa
Ei tuettu
IDE
Henkilöt
 Ohjelmointikielet