Pascal (programmeringssprog)

Den aktuelle version af siden er endnu ikke blevet gennemgået af erfarne bidragydere og kan afvige væsentligt fra den version , der blev gennemgået den 16. maj 2022; checks kræver 3 redigeringer .
Pascal
Sprog klasse imperativ , struktureret
Udførelsestype kompileret
Dukkede op i 1970
Forfatter Niklaus Wirth
Filtypenavn _ .pasfor kodefiler, .incfor header-filer .
Frigøre ISO/IEC 10206:1991 Stage: 90,93 ( 29. juli 2008 )
Type system statisk , stærk , sikker [1]
Større implementeringer CDC 6000 , ICT 1900 , Pascal-P , PDP-11 , PDP-10 , IBM System/370 , HP , Free Pascal , GNU , PascalABC.NET
Dialekter UCSD , Turbo , Delphi
Blev påvirket ALGOL
påvirket Modula-2 , Oberon , Component Pascal , Ada , Object Pascal , Java [2] [3] [4] , Oxygene
Internet side iso.org/standard/18237.h…
 Mediefiler på Wikimedia Commons

Pascal eret af de mest kendte programmeringssprog [  5 ] , der bruges til undervisning i programmering i gymnasiet og i de første år på universiteter, er grundlaget for en række andre sprog.

Historie

Pascal-programmeringssproget blev skabt i 1970 baseret på Algol-60- sproget [6] .

Pascal blev skabt af Niklaus Wirth i 1968-1969 efter hans deltagelse i arbejdet i Algol-68 sprogstandardudviklingsudvalget . Sproget er opkaldt efter den franske matematiker, fysiker, forfatter og filosof Blaise Pascal , som skabte en af ​​verdens første mekaniske maskiner til at tilføje to tal . Wirths første udgivelse om sprog er dateret 1970; Ved at præsentere sproget angav forfatteren som målet med dets skabelse konstruktionen af ​​et lille og effektivt sprog, der fremmer en god programmeringsstil ved hjælp af struktureret programmering og strukturerede data.

Wirths efterfølgende arbejde var at skabe et systemprogrammeringssprog baseret på Pascal og samtidig bevare evnen til at gennemføre et systematisk, holistisk forløb med professionel programmeringsuddannelse på basis af det: “ Den vejledende idé var at konstruere en ægte efterfølger af Pascal, der opfylder kravene til systemteknik. , men også for at tilfredsstille min lærers trang til at præsentere en systematisk, konsekvent, tiltalende og lærenem ramme for professionel programmering. ". Resultatet af dette arbejde var Modula-2 sproget , hvorefter Wirth begyndte at udvikle det objektorienterede programmeringssprog Oberon baseret på alle tidligere udviklinger [6] .

Niklaus Wirth betragtede et af målene med at skabe Pascal-sproget for at lære eleverne strukturel programmering. Indtil nu er Pascal fortjent betragtet som et af de bedste sprog til indledende programmeringslæring. Dens moderne modifikationer, såsom Object Pascal, er meget brugt i industriel programmering (Delphi-miljø). Baseret på syntaksen for Pascal-sproget blev programmeringssproget Structured Text (ST) eller Structured Control Language (SCL) til programmerbare logiske controllere oprettet .

I 1990'erne var Pascal blevet et af verdens mest udbredte algoritmiske programmeringssprog. Førende softwareudviklere udgav jævnligt nye versioner af deres compilere til dette sprog. Tidens populære compilere: Turbo Pascal (udviklet af Borland ), Microsoft Pascal Compiler, Quick Pascal, Pascal-2, Professional Pascal, USCD Pascal [7] .

Implementeringer og dialekter

Pascal-sproget har mange implementeringer [8] .

UCSD Pascal

I 1978 blev UCSD p-systemet udviklet ved University of California i San Diego , som omfattede en port af Wirth-kompileren fra Pascal-sproget til bærbar p-kode , en kildekodeeditor, et filsystem osv. [9 ] , og implementerede også et betydeligt antal sprogudvidelser Pascal, såsom moduler, tegnstrenge med variabel længde, oversættelsesdirektiver, I/O-fejlhåndtering, henvisning til filer ved navn og mere. Efterfølgende var de vigtigste implementeringer af Pascal-sproget baseret på denne dialekt.

ObjectPascal

I 1986 udviklede Apple en objektudvidelse til Pascal-sproget, hvilket resulterede i Object Pascal . Den blev udviklet af Larry Teslers gruppe , som rådførte sig med Niklaus Wirth .

Turbo Pascal og Object Pascal

I 1983 dukkede den første version af Borlands Turbo Pascal integrerede udviklingsmiljø op , baseret på Pascal-implementeringen af ​​samme navn.

I 1989 blev en objektsprogsudvidelse tilføjet til Turbo Pascal version 5.5.

Den seneste version (7.0) er blevet omdøbt til Borland Pascal.

Objektfaciliteterne er lånt fra Apples Object Pascal, og der er meget få sproglige forskelle mellem Object Turbo Pascal 5.5 og Apples Object Pascal.

Næsten samtidig med Borland udgav Microsoft sin version af det objektorienterede sprog Pascal. [10] [11] Denne version af Pascal blev ikke brugt meget.

Yderligere udvikling af Pascal-implementeringen fra Borland gav anledning til Borlands Object Pascal -variant , senere under udviklingen af ​​Delphi -programmeringsmiljøet , som fik samme navn .

Midlet Pascal

Moderne versioner af Object Pascal

Et vigtigt skridt i udviklingen af ​​sproget er fremkomsten af ​​gratis implementeringer af Pascal-sproget Free Pascal og GNU Pascal , som ikke kun absorberede funktionerne i mange andre dialekter af sproget, men også sikrede ekstremt bred portabilitet af programmer skrevet i det (for eksempel understøtter GNU Pascal mere end 20 forskellige platforme, under over 10 forskellige operativsystemer, Free Pascal giver specielle kompatibilitetstilstande med forskellige almindelige dialekter i sproget, såsom Turbo Pascal (fuld kompatibilitet), Delphi og andre).

Siden Delphi 2003 er der skabt en sprogimplementering til .Net -platformen , selvom udviklere fortsætter med at bruge Delphi fra tidligere versioner.

Lidt er i øjeblikket kendt om kommerciel udvikling i Free Pascal, GNU Pascal og TMT Pascal .

Derudover har Southern Federal University udviklet PascalABC.NET  , et Pascal-programmeringssprog, der indeholder de fleste funktioner i Delphi -sproget , samt en række af dets egne udvidelser. Den er baseret på Microsoft.NET -platformen og indeholder næsten alle moderne sprogfunktioner: klasser , operatøroverbelastning , grænseflader , undtagelseshåndtering , generiske klasser og underrutiner , affaldsopsamling , lambda-udtryk .

Funktioner af sproget

Sprogets funktioner er streng indtastning og tilgængeligheden af ​​strukturelle (proceduremæssige) programmeringsværktøjer . Pascal var et af de første sådanne sprog. Ifølge Wirth skulle sproget bidrage til disciplineret programmering, derfor er mulige syntaktiske uklarheder minimeret i Pascal, sammen med stærk maskinskrivning, og forfatteren forsøgte at gøre selve syntaksen intuitiv allerede ved første bekendtskab med sproget.

Men oprindeligt havde sproget en række begrænsninger: umuligheden af ​​at overføre arrays af variabel længde til funktioner, manglen på normale midler til at arbejde med dynamisk hukommelse , et begrænset I/O-bibliotek , manglen på midler til at forbinde funktioner skrevet i andre sprog, manglen på separate kompileringsværktøjer osv. En detaljeret analyse af manglerne ved datidens Pascal-sprog blev udført af Brian Kernighan i artiklen "Hvorfor Pascal ikke er mit yndlingsprogrammeringssprog" [12] (denne artikel dukkede op i begyndelsen af ​​1980'erne, da Modula-2 , en efterkommer af Pascal, slap af med de fleste af sine laster, såvel som mere udviklede dialekter af Pascal). Nogle mangler ved Pascal blev rettet i 1982 ISO-standarden, især åbnede arrays dukkede op i sproget, hvilket gjorde det muligt at bruge de samme procedurer til behandling af endimensionelle arrays af forskellige størrelser.

Mange af sprogets mangler viser sig dog ikke eller bliver endda fordele, når man lærer at programmere. Derudover repræsenterede Pascal et væsentligt skridt fremad sammenlignet med det vigtigste programmeringssprog i det akademiske miljø i 1970'erne (som var Fortran , som havde meget mere væsentlige ulemper). I 1980'erne blev Pascal grundlaget for adskillige uddannelsesprogrammer, i nogle tilfælde blev der oprettet specialiserede undervisningsprogrammeringssprog på grundlag heraf, for eksempel i begyndelsen af ​​1980'erne i USSR udviklede Andrei Ershov et Algol-Pascal-lignende sprog at lære skolebørn det grundlæggende i datalogi og computerteknologi. " at lære algoritmisk sprog ".

Den mest berømte implementering af Pascal, som sikrede den brede distribution og udvikling af sproget, er Borlands Turbo Pascal , som siden voksede til objektet Pascal til DOS (startende med version 5.5) og Windows og videre til Delphi, hvor et betydeligt sprog udvidelser blev indført.

Standarder

Efter at brugen af ​​Pascal begyndte i 1970, og fremkomsten af ​​implementeringer, der adskilte sig ikke kun i tilføjelser, men også i syntaks, blev spørgsmålet om standardisering af sproget rejst. Sprogstandarden blev udviklet af Niklaus Wirth i 1974 sammen med Kathleen Jensen. [13] Efterfølgende blev en international standard fra ISO og en amerikansk standard fra ANSI vedtaget. I øjeblikket er der tre grundlæggende forskellige standarder: Uudvidet Pascal (original), Udvidet Pascal (udvidet), Objektorienteret Udvidelse til Pascal (objektorienteret Pascal-udvidelse).

Pascal sprogstandarder: Kilde, International ISO og amerikansk ANSI
Navn Mulighed Hvem/hvor udviklet skabelsesår
Pascal Standard initial N. Wirth, Kathleen Jensen 1974
Pascal Standard initial ISO 7185:1983
ANSI/ IEEE 770X3.97:1983		 1982
Uforlænget Pascal initial ISO 7185:1990 1989
Forlænget Pascal udvidet ANSI/IEEE 770X3.160:1989 1989
ISO/ IEC 10206 1991
Objektorienterede
udvidelser til Pascal [14] 		objektorienteret udvidelse ANSI/X3-TR-13:1994 1993

En af de vigtigste yderligere funktioner i den objektorienterede Extended Pascal-udvidelse var modularitet og faciliteter, der letter separat kompilering.

Standardiseringen af ​​sproget haltede bagefter den faktiske fremkomst af visse træk i sproget. Kommercielle implementeringer har udvidet standard Pascal; dette er blevet gjort i UCSD Pascal, Apples modifikation af Object Pascal , Borlands Turbo Pascal (en let modificeret version af Apple) og dens udløbere. Ingen af ​​de almindelige kommercielle implementeringer af Pascal er helt i overensstemmelse med nogen af ​​de officielle sprogstandarder.

Syntaks og sprogkonstruktioner

Pascal er i sin oprindelige form et rent proceduresprog og omfatter mange Algol-lignende strukturer og reserverede ordkonstruktioner som if, then, else, while, forosv repeat. Pascal rummer dog også en lang række muligheder for at strukturere information og abstraktioner , som mangler. fra den originale Algol-60 , såsom typedefinitioner , optegnelser , pointere , enums og sæt . Disse konstruktioner blev delvist arvet eller inspireret fra Simula -67 , Algol-68 skabt af Niklaus Wirth AlgolWog foreslået af Hoare .

På moderne dialekter (Delphi Pascal, Free Pascal) er operationer som operatør- og funktionsoverbelastning tilgængelige.

Hej Verden!

Pascal-programmer begynder med et nøgleord Program efterfulgt af programnavnet efterfulgt af et semikolon (valgfrit i nogle dialekter), navnet kan efterfølges i parentes af en liste over eksterne filbeskrivelser ("miljø") som parametre; den efterfølges af programmets brødtekst, der består af sektioner, der beskriver konstanter ( Const), typer ( Type), variabler ( Var), procedureerklæringer ( ) og funktioner ( ) og sætningsblokken efter dem , som er indgangspunktet til program. I Pascal er blokken begrænset til nøgleordene og . Udsagn er adskilt af semikolon , efter at kroppen er placeret et punktum , som tjener som et tegn på afslutningen af ​​programmet. ProcedureFunctionbeginend

Tilfældet med karakterer i Pascal er ligegyldigt.

Således ville det enkleste ("blanke") Pascal-program se sådan ud:

program p ; begynde slutningen .

Ovenstående program gør intet og indeholder en tom blok af udsagn.

Et eksempel på et program, der udskriver strengen " Hej, verden!" »:

program hej ; begynde writeln ( 'Hej, verden!' ) ; // string output operator ende .

Datatyper

Simple typer

Der er simple typer i standard og udvidet Pascal: flydende komma ( real), heltal ( integer), tegn ( char), boolsk ( boolean) og opregninger (ny type konstruktør introduceret i Pascal).

Turbo Pascal har tilføjet variationer af disse typer til sproget: for eksempel vil shortintdet være kortere integer, og det vil være longint længere.

Moderne dialekter af Pascal, såsom FPC eller Delphi , mener, at integer - dette er det heltal, der er bedst egnet til en given maskine, brugt for eksempel til matrixindekser og shortint, longintog andre - heltal af en vis længde; dette er praktisk til programmering på tværs af platforme . Ligeledes med brøktal.

Typerne blev udvidet igen ved skift til x64  - "bare et heltal" ( integer) forblev 32-bit, men en speciel type var påkrævet, som er lig longintmed x86 og int64x64.

Heltalstyper:

Type Rækkevidde Format Størrelse i bytes Noter
bytes 0..255 usigneret en
ShortInt −128..127 Ikonisk en
SmallInt −32768..32767 Ikonisk 2 Kan ikke eksistere; i stedet et heltal med samme interval
Ord 0..65535 usigneret 2
langt ord 0..4294967295 usigneret fire
LongInt −2147483648..2147483647 Ikonisk fire
int64 −9223372036854775808..9223372036854775807 Ikonisk otte
QWord 0..18446744073709551615 usigneret otte
Heltal -32768..32767. Ikonisk 2 eller 4 Det hurtigste heltal; SmallInt eller LongInt
kardinal ? usigneret ? Det hurtigste heltal; normalt LongWord
NativeInt ? Ikonisk ? Matcher maskinregister; LongInt eller Int64
NativeUInt ? usigneret ? Matcher maskinregister; LongWord eller QWord

Flydende kommatal:

Type Rækkevidde Antal signifikante cifre Størrelse i bytes Support
Ægte platform afhængig ??? ??? Alle oversættere; på moderne svarer det normalt til Double
Virkelig 48 2.9E−39..1.7E38 11-12 6 Borland; i Turbo Pascal hed det Real; bruger ikke en coprocessor og derfor gentages resultatet til bit
Enkelt 1.5E−45..3.4E38 7-8 fire De fleste muligheder under IEEE 754 kompatible maskiner
Dobbelt 5.0E-324..1.7E308 15-16 otte De fleste muligheder under IEEE 754 kompatible maskiner
Udvidet 3.4E-4951..1.1E4932 19-20 ti De fleste muligheder for x86
Comp −9223372036854775808..9223372036854775807 otte Borland; 8-byte heltal beregnet på coprocessoren; relevant for 16-bit x86
betalingsmiddel −922337203685477.5808..922337203685477.5807 otte Borland og andre compilere til Windows; forbundet med OLE ; fikspunkt med enhed lig med 10000
var { variabel declaration section } r : Real ; { variabel af reel type } i : Heltal ; { variabel af heltalstype } c : Char ; { karaktervariabel } b : Boolean ; {boolean} s : Streng ; { string variabel } t : Tekst ; { variabel til at erklære en tekstfil } e : ( æble , pære , banan , appelsin , citron ) ; { enum-type variabel }

I Pascal er bitvise operationer tilladt på heltalstyper (byte, shortint, word, heltal, longint og deres intervaller). Logiske operationer på bits:

På bits af to heltalsoperander kan du udføre de tidligere betragtede logiske operationer: ikke, og, eller, xor. Forskellen mellem bitvise og logiske operationer er, at bitvise (bitvise) operationer udføres på individuelle bits af operanderne, og ikke på deres værdi i decimal (normalt) repræsentation.

Begrebet ordinaldatatyper (ordinal) skelnes, de omfatter heltalstyper (med og uden fortegn), logiske ( boolean), tegn ( char), optalte typer og intervaltyper.

Ordinaltyper er specificeret med et heltal (kode), som kan opnås ved hjælp af ord-funktionen. Alle operationer udført på ordinaltyper udføres på deres koder.

Områder indeholder en delmængde af værdier af andre ordinaltyper:

var x : 1 .. 10 ; y : 'a' .. 'z' ; z : pære..orange ; _ _

For ordinaltyper defineres operationer inc, dec, succ, pred, ord, sammenligningsoperationer ( = > < => <= <>), de kan bruges i operatorer case, for(som en loop-tæller), som array-grænser til at specificere elementer af sæt og områdetyper.

I Pascal, i modsætning til C-lignende sprog, er heltals aritmetiske operationer ikke defineret med booleantyper char.

Sætter

I modsætning til mange almindelige sprog understøtter Pascal en speciel sæt datatype :

var sæt1 : sæt af 1 .. 10 ; sæt2 : sæt af 'a' .. 'z' ; sæt 3 : sæt pære ..orange ; _

Et sæt er et grundlæggende begreb i moderne matematik, som kan bruges i mange algoritmer.

I Pascal kan en sættype kun indeholde elementer af samme type ordinaltype. Denne funktion er meget udbredt og er normalt hurtigere end den tilsvarende konstruktion i et sprog, der ikke understøtter sæt. For eksempel for de fleste Pascal-kompilere:

hvis jeg er i [ 5 .. 10 ] så { tjekker om elementet tilhører sættet } ...

behandles hurtigere end

hvis ( i >= 5 ) og ( i <= 10 ) så { boolsk test } ...

For at indstille værdien af ​​sættet bruges en liste over sætelementer, adskilt af kommaer og omgivet af firkantede parenteser (som allerede vist ovenfor):

var { variabel declaration section } d : sæt af char ; start {start af blok} d := [ 'a' , 'b' ] ; ...

I Jensen og Wirths Pascal blev strenge repræsenteret som pakkede rækker af karakterer; derfor havde de en fast længde og var normalt polstret til den længde med mellemrum.

Sammensatte typer

Nye typer kan defineres fra eksisterende:

type { type declaration section } x = Heltal ; y = x ; ...

Desuden kan sammensatte typer konstrueres ud fra primitive typer:

type { type declaration section } a = Matrix [ 1 .. 10 ] af heltal ; { array definition } b = record { record definition } x : Heltal ; y : Char ; ende ; c = Fil af a ; { fil definition }

Filtyper i Pascal er opdelt i maskinskrevet, tekst og filer uden typer.

Som vist i eksemplet ovenfor er indtastede filer i Pascal sekvenser af elementer af samme type. For hver fil er der en bufferpointer-variabel, betegnet med f^. Procedurer get(til læsning) og put(til skrivning) flytter markøren til det næste element. Læsning er implementeret på en sådan måde, at read(f, x)det er det samme som get(f); x:=f^. Følgelig er posten implementeret på en sådan måde, at write(f, x)den er den samme som f^ := x; put(f). Tekstfiler er textdefineret som en typeudvidelse file of charog tillader, ud over standardhandlinger på maskinskrevne filer (læsning, skrivning af et tegn), tegninput/output til en fil med alle typer data, svarende til konsolinput/output.

Filer uden typer erklæres som variabler af typen file. Med dem kan du udføre byte-for-byte utypede I/O-operationer for flere blokke af bytes af en specificeret længde gennem en buffer, til dette bruges specielle procedurer blockreadog blockwrite(UCSD-udvidelse).

Strings

Modern Pascal [15] bruger den indbyggede type string, som understøtter sammenkædning ( +) og sammenligning ( > < = <> >= <=), til at arbejde med strenge. Strengene sammenlignes i leksikografisk rækkefølge . For eksempel betragtes strenge som ens, hvis de har samme længde, og koderne for alle tegn med det samme indeks matcher.

Typen string [n]eller blot stringi dialekterne i sproget i 1970'erne-1990'erne blev defineret som et array af tegn array [0..n] of char(n tog som standard værdien 80 i UCSD Pascal og 255 i Turbo / Borland Pascal), nul-elementet i arrayet i denne repræsentation tjener til at indstille længden af ​​strengen, henholdsvis strengen kan have en maksimal størrelse på 255 tegn. Som standard, i Delphi og FreePascal, bruges AnsiString-typen som en streng, hvor hukommelsen er dynamisk allokeret og frigivet af compileren, og den maksimale strengstørrelse i aktuelle implementeringer er 2 gigabyte. Derudover kan UnicodeString-typen i Delphi og Free Pascal bruges som en type, hvor der bruges en 16-bit repræsentation af tegn i UCS-2-string kodning , mens der ikke er nogen måder at konvertere fra enkeltbyte strenge til multibyte strenge og tilbage i FPC-standardbiblioteket, men er tilgængelige i Delphi.

Delphi 2009 og nyere har en konstruktion til at erklære en AnsiString med en specifik tegntabel:

type CyrillicString = AnsiString ( 1251 ) ; CP866String = AnsiString ( 20866 ) ; Pointers

Pascal understøtter brugen af ​​pegepinde (skrevne ^типog ikke-tastede pointer):

skriv a = ^ b ; b = post x : Heltal ; y : Char ; z : a ; ende ; var pointer_to_b : a ;

Her er variablen pointer_to_b en pegepind til datatypen b, som er en post. En maskinskrevet pointer kan defineres ( lookahead ) før erklæringen af ​​den type, den refererer til. Dette er en af ​​undtagelserne fra reglen , som siger, at ethvert element (konstant, type, variabel, procedure, funktion) skal erklæres, før det bruges . Introduktionen af ​​denne undtagelse giver dig mulighed for at organisere tilbagevendende definitioner af datastrukturer, herunder såsom lineære lister , stakke , køer , træer, herunder en pointer til en post i beskrivelsen af ​​denne post (se også: null pointer - nil).

For en indtastet pointer er en dereferenceoperation defineret (dens syntaks er: указатель^).

For at oprette en ny post og tildele en værdi 10og et symbol til Afelterne xog yi den, kræves følgende udsagn:

ny ( pointer_to_b ) ; { hukommelsesallokering til markør } pointer_to_b ^. x := 10 ; {dereferencing the pointer and access the record field } pointer_to_b ^. y := 'A' ; pointer_to_b ^. z : = nul ... disponere ( pointer_to_b ) ; { frigør hukommelse fra under markøren }

Du kan også bruge operatoren til at henvise til felter i poster og objekter with, som vist i eksemplet:

ny ( pointer_to_b ) ; med pointer_to_b ^ begynder x : = 10 ; y := 'A' ; z := ingen ende ; ... disponere ( pointer_to_b ) ; Proceduretype

På Pascal Jensens og Wirths originalsprog blev den proceduremæssige type kun brugt ved beskrivelse af en formel parameter. Der var allerede en fuld proceduretype i TP . Typedeklarationen indeholder overskriften på en procedure eller funktion (uden navn), som generelt beskriver subrutinens grænseflade. En værdi af denne type indeholder en pointer til en underrutine med en titel svarende til den, der er erklæret i typeerklæringen. En variabel identifikator kan bruges til at kalde den tilsvarende procedure eller funktion.

Subrutine eksempel for Pascal type myfunc = funktion : streng ; func1 : streng ; _ start func1 := 'func #1' end ; func2 : streng _ _ start func2 := 'func #2' slut ; var sjov : min func ; begynde sjov :=@ func1 ; writeln ( sjov ) {func1-funktionen kaldes} ende .

Kontroludsagn

Pascal er et struktureret programmeringssprog , hvilket betyder, at et program består af separate standardsætninger, der udføres sekventielt, ideelt set uden brug af en kommando GOTO.

Eksempel for Pascal mens a <> b gør { loop med forudsætning } writeln ( 'Venter' ) ; hvis a > b så { conditional statement } writeln ( 'Betingelse opfyldt' ) else {else-sektion - kan udelades} writeln ( 'Betingelse mislykkedes' ) ; for i := 1 til 10 gør { iteration loop } writeln ( ' Iteration # ' , i : 1 ) ; for i i [ 1 .. 10 ] do { iterate through the set } writeln ( ' Iteration # ' , i : 1 ) ; { dukkede op i version 2.4.0 } med en do {Operator With - a method to speed up access to record fields} start l := 1 ; k := 2 ; p :=- 3 ; ende ; gentag { postcondition loop } a := a + 1 indtil a = 10 ; case i af { betinget multiple choice-operator } 0 : skriv ( 'nul' ) ; 1 : skriv ( 'en' ) ; 2 : skriv ( 'to' ) else skriv ( 'ukendt nummer' ) { else-sektion - kan udelades} ende ;

I sætninger while, for, ifkan en blokcase bruges som en eksekverbar sætning . En sådan konstruktion, som er en almindelig sætning eller blok, kaldes en kompleks sætning .

I Turbo Pascal, for at kontrollere kompileringsprocessen, er der direktiver, der er placeret i kommentarer og giver dig mulighed for at skifte compilerens driftstilstande - for eksempel aktivere og deaktivere kontroller for I/O-operationer, overløb:

Eksempel for Pascal assign ( inp , 'text.txt' ) ; {$I-} { deaktiver IO-kontroltilstand - generering af programafslutningskode i tilfælde af I/O-fejl } { (til tilfældet, hvis filen ikke findes)} nulstil ( inp ) ; {$I+} { enable IO checking mode } if IOresult = 0 then start { check the value of the variable ioresult(<>0 in case of I/O error) } ... close ( inp ) ; end else writeln ( 'fil ikke fundet' )

Der er direktiver, der ligner C/C++ præprocessor-direktiverne ( $ifdef, $define, $include), de behandles af compileren under kompilering.

Procedurer og funktioner

I Pascal er subrutiner opdelt i procedurer og funktioner. Samtidig returnerer funktioner eksplicit en værdi (resultat) af en bestemt type, og procedurer returnerer eksplicit ikke noget.

Syntaktisk består beskrivelsen af ​​en procedure eller funktion af en overskrift , der indeholder nøgleordet procedureeller functionnavnet, som kan efterfølges af en beskrivelse af de beståede (formelle) parametre i parentes. :For en funktion er returværdiens type angivet med kolon-tegnet . Titlen slutter med et semikolon ;. Overskriften efterfølges af brødteksten , der (muligvis) indeholder beskrivelsessektioner af lokale konstanter, typer, variabler, procedurer, funktioner og (påkrævet) indeholdende en blok af udsagn, efterfulgt af et semikolontegn ;.

Eksempel program til Pascal program ( udgang ) ; _ var i : heltal ; procedure print ( var j : heltal ) ; funktion næste ( k : heltal ) : heltal ; begynde næste := k + 1 ende ; start writeln ( 'Total: ' , j ) ; j := næste ( j ) ende ; begynde i := 1 ; mens i < = 10 udskriver ( i ) slutter .

Brødteksten i en procedure, ligesom et program, kan igen indeholde beskrivelser af procedurer og funktioner. Således kan procedurer og funktioner indlejres så dybt som ønsket, mens programmets krop er den øverste i kæden.

Desuden er indholdet af afsnittene i beskrivelsen af ​​variabler, typer, konstanter, eksternt organ (procedurer, funktioner, programmer), placeret før beskrivelsen af ​​proceduren/funktionen, tilgængeligt i det. I de fleste dialekter kan du også få adgang til parametrene for en ekstern procedure fra en procedure.

Efter overskriften af ​​procedurer/funktioner, i stedet for brødteksten, kan søgeordet placeres forward, dette gøres hvis beskrivelsen af ​​proceduren/funktionen ligger i programmet efter dets kald, og er forbundet med muligheden for at kompilere programmet i et pas understøttet i Pascal.

Pascals matematiske standardfunktioner og -procedurer Matematiske funktioner
Funktionsnavn Argumenttype Værditype Beregningsresultat
Abs(x) helt ægte helt ægte Den absolutte værdi af "x"
synd(x) ægte ægte sinus "x" rad.
Cos(x) ægte ægte cosinus "x" rad.
Arctan(x) ægte ægte buetangens af "x" ( -Pi/2 <y< Pi/2 )
Sqrt(x) ægte ægte kvadratroden af ​​"x"
Sqr(x) helt ægte helt ægte værdien af ​​"x" i anden kvadrat ( x 2 )
effekt(a,x) ægte ægte værdien af ​​"a" i potensen af ​​"x" ( a x )
exp(x) ægte ægte værdien af ​​"e" i potensen af ​​"x" ( e x , hvor e = 2,718282... )
Ln(x) ægte ægte naturlig logaritme af "x" ( x > 0 )
frac(x) ægte ægte brøkdel "x"
Int(x) ægte ægte heltalsdel "x"
Tilfældig - ægte tilfældigt tal ( 0 <=y< 1 )
Tilfældig(x) Ord Ord tilfældigt tal ( 0 <=y< x )
Succ(c) ordinal ordinal tegn efter "s"
pred(c) ordinal ordinal forudgående "med"-tegn
Matematiske procedurer
Funktionsnavn Argumenttype Værditype Beregningsresultat
Inc(x) hel hel Øger "x" med 1 ( x:=x+1; )
dec(x) hel hel Formindsker "x" med 1 ( x:=x-1; )
Inc(x, n) hel hel "x" med n ( x:=x+n; )
Dec(x, n) hel hel "x" med n ( x:=xn; )
Procedurer for konvertering af variabeltype
Funktionsnavn Argumenttype Værditype Beregningsresultat
Str(x, s) x-heltal eller reelt s-streng Rækkefølgen af ​​tegn "s" fra cifrene i tallet "x"
Val(er, v, torsk) s-streng v-heltal eller ægte torskeheltal Binær form af sekvensnummer "s" cod=0 (fejlkode)
Variabel type konverteringsfunktioner
Funktionsnavn Argumenttype Værditype Beregningsresultat
Trunc(x) ægte LongInt heltalsdel "x"
Runde(x) ægte LongInt afrunde "x" til et heltal
Ulige (x) hel logisk returnerer Sand, hvis "x" er et ulige tal
Chr(x) bytes Char ASCII-kodetegn "x"
Ord(x) Char bytes ASCII-tegnkode "x"

Moduler

Før fremkomsten af ​​forbundne moduler i deres moderne form, understøttede nogle implementeringer af Pascal modularitet på grund af mekanismen til at inkludere header-filer, svarende til mekanismen #includei C-sproget: ved at bruge et særligt direktiv formateret som en pseudo-kommentar, for eksempel, {$INCLUDE "файл"}, indholdet af den angivne fil blev direkte inkluderet i programmets kildekode. , i tekstform. Det var således muligt at opdele programkoden i mange fragmenter, for at lette redigeringen, men inden kompileringen blev de automatisk kombineret til én programfil, som til sidst blev behandlet af compileren. Denne implementering af modularitet er primitiv og har mange åbenlyse mangler, så den blev hurtigt udskiftet.

Moderne Pascal-implementeringer (startende med UCSD Pascal) understøtter moduler. Programmoduler kan være af to typer: hovedprogrammodulet, der som sædvanligt begynder med nøgleordet program, og hvis krop indeholder kode, der køres efter programmet er indlæst i hukommelsen, og hjælpemoduler, der indeholder typer, konstanter, variabler, procedurer og funktioner beregnet til brug i andre moduler, herunder hovedmodulet.

Struktur

Den generelle struktur for et plug-in i Pascal er som følger:

enhed UnitName1 ; interface ... implementering ... start {kan udelades - bruges hvis initialiseringsudsagn skal placeres} ... end .

En anden mulighed er også mulig:

enhed UnitName2 ; interface ... implementering ... initialisering ... afslutning .... ende .

I modsætning til hovedprogrammet begynder en modulfil med nøgleordet UNITefterfulgt af modulnavnet og et semikolon. Moderne implementeringer kræver typisk, at navnet på et modul er det samme som navnet på den kildekodefil, der indeholder modulet. Et modul indeholder tre sektioner: en grænsefladesektion, en implementeringssektion og en modulkropp.

Grænsefladeafsnittet kommer først, starter med et nøgleord INTERFACEog slutter på det punkt i modulet, hvor implementeringsafsnittet eller kroppen begynder. Interfacesektionen erklærer de objekter (typer, konstanter, variabler, procedurer og funktioner - headers er placeret for dem), der skal være tilgængelige uden for modulet. I dette tilfælde er en delvis deklaration af typer tilladt: de kan erklæres uden at angive en struktur, med kun ét navn. Når du bruger denne type i et eksternt program, er det tilladt at erklære variabler og parametre af denne type, tildele værdier, men det er umuligt at få adgang til detaljerne om dets implementering. Procedurer og funktioner i grænsefladeafsnittet erklæres som forwards - overskrifter med parametre, men uden krop. Sammensætningen af ​​modulets grænsefladesektion er sådan, at det er tilstrækkeligt at generere kode, der bruger dette modul. Variabler, der er erklæret i grænsefladeafsnittet, er globale, det vil sige, at de eksisterer i en enkelt instans og er tilgængelige i alle dele af programmet, der bruger dette modul.

Implementeringsafsnittet følger grænsefladeafsnittet og begynder med nøgleordet IMPLEMENTATION. Den indeholder beskrivelser af procedurer og funktioner, der er erklæret i grænsefladeafsnittet, samt beskrivelser af typer, konstanter, variabler, procedurer og funktioner, der er nødvendige for at implementere grænsefladeprocedurer og -funktioner. Beskrivelsen af ​​en procedure eller funktion, der er deklareret i et grænsefladeafsnit, skal have nøjagtig samme overskrift som i deklarationen. Organet kan bruge andre procedurer og funktioner i dette modul, deklareret både i grænsefladedelen og i implementeringsafsnittet. Variabler, der er erklæret i implementeringsafsnittet, er faktisk globale (det vil sige, at der kun er én forekomst af hver sådan variabel i hele programmet), men de er kun tilgængelige fra de procedurer og funktioner, der er beskrevet i implementeringsafsnittet af dette modul, såvel som fra dens krop. Hvis der er forkortede typedeklarationer i grænsefladeafsnittet, skal disse typer deklareres fuldt ud i implementeringsafsnittet.

Brødteksten i et modul begynder med nøgleordet på det øverste niveau af indlejring BEGIN. Brødteksten indeholder programkode, der udføres én gang, når modulet indlæses. Kroppen kan bruges til initialisering, tildeling af begyndelsesværdier til modulvariabler, tildeling af ressourcer til dens drift og så videre. Modulets krop mangler muligvis. I en række Pascal-implementeringer, for eksempel i Delphi, kan to sektioner (også valgfrit) bruges i stedet for modulet body - INITIALIZATIONog FINALIZATION. De placeres i slutningen af ​​modulet efter det tilsvarende søgeord. Den første, initialiseringssektionen, indeholder den kode, der skal udføres, når modulet indlæses; den anden, finaliseringssektionen, indeholder den kode, der vil blive eksekveret, når modulet aflæses. Afslutningssektionen kan udføre handlinger, vende initialiseringer - fjerne objekter fra hukommelsen, lukke filer, frigive tildelte ressourcer.

ENDModulet afsluttes med et prik nøgleord .

Brug

For at bruge et modul skal hovedprogrammet eller et andet modul importere modulet, det vil sige indeholde en erklæring om dets brug. Denne erklæring er lavet med en module include statement, som er nøgleordet USESefterfulgt af et kommasepareret navn på de moduler, der skal inkluderes. Tilslutningsinstruktionen skal umiddelbart følge programoverskriften, eller efter nøgleordet, INTERFACEhvis forbindelsen er lavet i et modul.

Moduler forbundet i grænsefladedelen kan bruges i hele modulet - både i implementeringsdelen og i kroppen. Men implementeringssektionen kan have sin egen instruktion (den følger nøgleordet IMPLEMENTATION), der indeholder navnene på plug-ins, der ikke er i grænsefladesektionen, men som er nødvendige for implementeringssektionen. En grund til at bruge en separat forbindelsesliste til implementeringsafsnittet er, når to eller flere moduler bruger hinanden. For at undgå cirkulære henvisninger i erklæringerne om brugen af ​​sådanne moduler, skal mindst et af dem inkludere det andet i implementeringsafsnittet.

Alle objekter, der er angivet i modulernes grænsefladesektioner, kan bruges i det program, hvor disse moduler er forbundet. Navnene på objekter importeret fra plug-ins forbliver de samme og kan bruges direkte. Hvis to eller flere tilsluttede moduler har objekter, der har samme navn, og compileren ikke kan skelne mellem dem, vil der blive genereret en kompileringsfejl - tvetydig navnespecifikation, når du forsøger at bruge et sådant objekt. I dette tilfælde skal programmøren anvende navnekvalifikation - angiv navnet i formatet "<modulnavn>.<objektnavn>".

Der kan opstå problemer, hvis der er behov for at bruge to forskellige moduler af samme navn i programmet. Hvis moduler kun er tilgængelige i kompileret form (det vil sige, det er umuligt at ændre deres navne), er det umuligt at importere dem på samme tid. Der er ingen standardløsning for en sådan kollision på sprogniveau, men specifikke compilere kan tilbyde en eller anden måde at omgå det på, især midlerne til at tildele aliaser til importerede moduler og direkte specificere hvilket modul der skal tages fra hvilken fil.

Kompilere og linke

Moduler er designet til at blive kompileret separat - compileren behøver ikke at kompilere importerede moduler for at kompilere det modul, der bruger dem. For at kompilere et modul korrekt, skal compileren dog have adgang til interfacesektionen for alle de moduler, den bruger. Der er to forskellige, nogle gange kombinerede, tilgange til at organisere en sådan adgang.

  • Moduler kompileres til binære filer af et specielt format (hver kompilator har sit eget), som gemmer detaljerede oplysninger om de objekter, der er erklæret i grænsefladeafsnittet, og kan også indeholde det objektsprog, der blev oprettet under modulkompilering, men det bruger kun grænsefladeafsnittet af modulet. Hvis et biblioteksmodul leveres i en kompileret form (uden fulde kildetekster), så er der sammen med den binære fil en trunkeret fil med modulets kildekode, som kun indeholder grænsefladeafsnittet. Dette er nok til, at compileren korrekt kan behandle opkald fra de brugermoduler, og på tidspunktet for kompilering af programmet inkluderer linkeren simpelthen den binære fil i programmet.
Indlæsning og aflæsning af moduler

For normal drift af modulet kan det være nødvendigt at udføre nogle handlinger, før du bruger det: initialisere variabler, åbne de nødvendige filer, allokere hukommelse eller andre ressourcer. Alt dette kan gøres i modulets krop eller i initialiseringssektionen. Det omvendte af initialisering udføres i afslutningsafsnittet.

Rækkefølgen for initialisering og færdiggørelse af moduler bestemmes indirekte af deklarationsrækkefølgen i afsnittet om anvendelser, men for statisk kompilerede programmer (hvor modulet enten er kompileret til én eksekverbar fil med hovedprogrammet eller placeret i et separat dynamisk bibliotek, men indlæst ved det indledende indlæsningstrin), garanterer compileren altid, at initialisering vil blive udført før den første brug af modulet. Afslutning foretages, når programmet afsluttes, efter at hovedmodulet er afsluttet, således at moduler, der bruges, afsluttes senere end dem, der bruger dem.

I tilfælde af dynamisk indlæsning af moduler styret af programmøren selv, udføres initialiseringer ved indlæsning, det vil sige i det øjeblik, hvor modulindlæsningskommandoen returnerede kontrol, er dens initialisering allerede blevet udført. Finaliseringen udføres efter aflæsning, normalt når modulets aflæsningskommando udføres. Hvis denne kommando ikke kaldes, afsluttes dynamisk indlæste moduler på samme måde som alle andre moduler - når programmet slutter.

Objektorienteret programmering

Objekt Pascal har evnen til at udvikle programmer ved hjælp af det objektorienterede programmeringsparadigme . Klasser defineres ved hjælp af en objectlignende type record, som ud over datafelter kan indeholde procedure- og metodeoverskrifter . Navnene på de beskrevne metoder følger klassenavnet adskilt af en prik.

Konstruktøren og destruktoren er angivet som almindelige procedurer, men i stedet for en identifikatorangivesprocedurenøgleordene og. I modsætning til C++- lignende sprog har de derfor et andet navn end klassenavnet, der kan være flere destruktorer, og de kan have parametre (i praksis bruges denne funktion sjældent, normalt har en klasse en enkelt destruktor, der tilsidesætter den virtuelle ødelægger af forældreklassen). constructordestructorDestroy

Enkelt arv, klasse polymorfi , virtuel metode mekanisme (ord virtualefter klasse metode header) er understøttet. Der er også dynamiske metoder (i TP er de beskrevet ved at tilføje et heltal efter ordet virtualog bruges hovedsageligt til meddelelsesbehandling; i Delphi og FreePascal bruges ordet til disse formål message, og ordet bruges til at skabe almindelige dynamiske metoder dynamic) , som er kendetegnet ved mindre hukommelsesforbrug og en lavere opkaldshastighed på grund af manglen på duplikering af dynamiske metoder fra forfædre i barnets VMT (FreePascal skelner dog ikke mellem virtuelle og dynamiske metoder).

I Delphi implementerede FPC operatøroverbelastning , abstrakte metoder, direktiver private, protected, public, published(klassemedlemmer er som standard public):

Eksempel program til Pascal type TbasicO = objektprocedure skriveByte ( b : byte ) ; _ virtuel ; abstrakt ; ende ; TtextO = objekt ( TbasicO ) { arver TbasicO, implementerer andre output-operationer baseret på writeByte} procedure writeS ( s : string ) ; {..} ende ; TfileO = objekt ( TbasicO ) {file output klasse - implementerer output operationen som output af en byte til en fil} constructor init ( n : string ) ; procedure skriveByte ( b : byte ) ; virtuel ; destructor closefile ; private f : fil af byte ; ende ; basicO = ^ TbasicO ; textO = ^ TtextO ; filO = ^ TfilO ; konstruktør TfileO . init ( n : streng ) ; begynde tildele ( f , n ) ; omskrive ( f ) ende ; destructor TfileO . luk fil ; begynde tæt ( f ) ende ; procedure TfileO . skriveByte ( b : byte ) ; begynde skrive ( f , b ) ende ; procedure TtextO . skrivS ( s : streng ) ; var i : heltal ; begynde for i := 1 til længde ( s ) do writeByte ( ord ( s [ i ])) ende ; {..} var f : fileO ; begynde ny ( f , init ( 'tstobj.txt' )) ; {allokerer hukommelse til objektet og kalder konstruktøren} textO ( f ) ^. writeS ( 'tekststreng' ) ; dispose ( f , closefile ) {kalder destruktoren og frigør objektets hukommelse} ende .

På Delphi-dialekten kan klasser også konstrueres ved hjælp af et ord class(desuden er gensidig nedarvning med object-klasser ikke tilladt) og grænseflader ( interface) introduceres - alle metoder er abstrakte og kan ikke indeholde datafelter.

Alle klasser (oprettet med class) arver TObjectfra , alle grænseflader stammer fra IUnknown. Klasser oprettet med classkan implementere flere grænseflader.

Grænseflader blev introduceret i Delphi for at understøtte Microsofts COM -teknologi.

Klasser ( Class) i modsætning til almindelige klasser ( Object) behøver ikke eksplicit allokering/deallokering af hukommelse, hukommelse til dem allokeres dynamisk af en konstruktør med navnet Create, kaldet med klassenavnet, og frigives når destruktoren med navnet kaldes Destroy(de kan have andre navne). En variabel af en sådan klasse, i modsætning til en klasse, objectgemmer adressen på en forekomst af klassen i hukommelsen, værdien nilbruges til at angive en tom reference, derfor, for at frigive et objekt, er der defineret TObjecten speciel metode , freeder kontrollerer referencen til nilog kalder den virtuelle destruktor Destroy. Kode, der bruger sådanne klasser, vil se sådan ud:

Eksempel for Pascal q1 := t1 . skabe ( 9 ) ; { construct object(t1 - class name) } writeln ( q1 . InstanceSize ) ; { viser størrelsen af ​​en klasseinstans } q1 . Gratis ; { objekt ødelæggelse } q1 := nul ; { så destruktoren ikke kaldes igen, når gratis kaldes }

I ændringen af ​​ObjectPascal/Delphi/FreePascal optræder egenskaber (egenskaber) i beskrivelsen af ​​klasser, som kombinerer bekvemmeligheden ved at arbejde med variabler (hvis rolle i OOP spilles af felter) og metodekald, der altid underretter objektet om en ændring i dens tilstand:

Eksempel program til Pascal type TMyObj = klasse ( TObject ) FProp : heltal ; procedure SetProp ( AValue : heltal ) ; egenskab MyProp : heltal læs FProp skriv SetProp ; ende ; procedure TMyObj . SetProp ( AValue : heltal ) ; start FProp := AValue ; Writeln ( 'Nogen har ændret MyProp!' ) ; ende ; var MyObj : TMyObj ; start MyObj := TMyObj . skabe ; MyObj . FProp := 5 ; MyObj . MyProp := MyObj . MyProp + 6 ; ende .

I det første tilfælde (ved at bruge MyObj.FProp) er objektets felt blevet ændret direkte, som et resultat, vil objektets metoder ikke have mistanke om, at dette felt tidligere er blevet ændret; i et mere komplekst tilfælde kan de stole på, at feltet er uændret, eller feltet kan tildeles en værdi, der er ugyldig for det givne objekt. I det andet tilfælde tildeles værdien direkte til objektets egenskab, hvilket refererer til et metodekald, der korrekt håndterer ændring af det givne felt.

Denne tilgang er praktisk, hvis objektet er forbundet med et visuelt element: direkte ændring af det felt, der er ansvarligt, for eksempel for bredden af ​​elementet, vil ikke påvirke selve det visuelle element, og objektet vil blive "misinformeret" om den faktiske størrelse af elementet. Den korrekte tilgang uden at bruge egenskaber er at udvikle metoder til at få og indstille en hvilken som helst feltværdi, men at arbejde med sådanne metoder vil være mindre bekvemt, for eksempel i stedet for den sidste linje, skulle man skrive

MyObj . SetProp ( MyObj . GetProp + 6 ) ;

desuden skulle MyObj.GetProp-metoden have været skrevet for at forene adgangen.

Af stor interesse er indeksegenskaber, som opfører sig på samme måde som arrays, der erstatter adgang til et array-element med et kald til den passende metode.

Egenskaber er dog ikke et "universalmiddel": Når de kompileres, oversættes egenskabskald direkte til metodekald eller direkte arbejde med felter, så egenskaber er ikke reelle variabler, især kan de ikke videregives som var-parametre.

Noter

  1. ↑ Kim B. Bruce. Grundlaget for objektorienterede sprog: typer og semantik . — MIT Press, 2002-01-01. - S. 9. - 416 s. — ISBN 9780262025232 . Arkiveret 18. juni 2016 på Wayback Machine
  2. ↑ Hvidbog. Om Microsofts "Delegerede" Arkiveret 27. juni 2012 på Wayback Machine , java.sun.com
  3. ↑ History of Java, Java Application Servers Report Arkiveret 29. december 2010. TechMetrix Research, 1999
  4. ↑ En samtale med James Gosling . Hentet 16. oktober 2009. Arkiveret fra originalen 16. juli 2015.
  5. ↑ TIOBE Programming Language Popularity Index Arkiveret 25. december 2018 på Wayback Machine 
  6. ↑ 1 2 Wirth, N. Modula-2 og Oberon // HOPL III  : Proceedings of the third ACM SIGPLAN conference on History of programmeringssprog: [ eng. ]  : [ bue. 22. december 2012 ]. - ACM, 2007. - Juni. — S. 3-1–3-10. - doi : 10.1145/1238844.1238847 .
  7. ↑ Borodich, Yu. S. Forord // Pascal for personlige computere: Ref. godtgørelse / Yu. S. Borodich, A. N. Valvachev, A. I. Kuzmich. - Mn.  : Højere skole, 1991. - S. 3. - 365 s. : syg. - BBK  32.973-01ya2 . - UDC  681.3.06 (035.5) . — ISBN 5-339-00662-X .
  8. ↑ Liste kompilator Pascal - Pascal kompilator liste . Hentet 19. januar 2021. Arkiveret fra originalen 11. april 2021.
  9. ↑ Wirth N. Erindringer om udviklingen af ​​Pascal (HOPL II), 3.3 . Hentet 16. april 2011. Arkiveret fra originalen 22. december 2012.
  10. ↑ Jon Udell, Crash of the Object-Oriented Pascals, BYTE, juli, 1989.
  11. ↑ MI Trofimov, The End of Pascal?, BYTE, marts, 1990, s. 36.
  12. ↑ Hvorfor Pascal ikke er mit foretrukne programmeringssprog . Dato for adgang: 27. august 2004. Arkiveret fra originalen den 28. april 2009.
  13. ↑ PASCAL: Brugervejledning og rapport ISO Pascal Standard Kathleen Jensen og Niklaus Wirth, 4. udgave, Springer Verlag New York, Inc. 1974, 1985, 1991
  14. ↑ Objektorienterede udvidelser til Pascal Arkiveret 5. juni 2021 på Wayback Machine , Teknisk Udvalg X3J9, Programmeringssprog Pascal
  15. ↑ ISO 7185 Pascal . Hentet 12. april 2009. Arkiveret fra originalen 25. november 2006.

Litteratur

  • Wirth N. Algoritmer + datastrukturer = programmer. — M .: Mir , 1985. — 406 s.
  • Wirth N., Jensen C. Pascal. Brugervejledning og sprogbeskrivelse. — M .: Finans og statistik , 1982. — 151 s.
  • Grogono P. Programmering i Pascal. — M .: Mir , 1982. — 384 s.
  • Kultin NB Delphi 6. Programmering i Object Pascal. - Sankt Petersborg. : BHV-Petersburg , 2001. - 528 s. — ISBN 5-94157-112-7 .
  • Morgun A. N. Programmering i Pascal. Grundlæggende om behandling af datastrukturer. - M .: Dialektik , 2005. - 576 s. — ISBN 5-8459-0935-X .
  • Perminov O. N. Programmeringssprog Pascal: En håndbog. - M .: Radio og kommunikation , 1989. - 128 s. — ISBN 5-256-00311-9 .
  • Rubenking NJ Turbo Pascal til Windows: i 2 bind. Om. fra engelsk. — M .: Mir, 1993.
  • Programmeringssprog Ada, C, Pascal = Sammenligning og vurdering af programmeringssprog Ada, C og Pascal / A. Feuer, N. Jehani. - M . : Radio og kommunikation, 1989. - 368 s. — 50.000 eksemplarer.  — ISBN 5-256-00309-7 .
Standarder

Links

  Gå til Wikidata-elementet  Ordbøger og encyklopædier
I bibliografiske kataloger
 Pascal
Dialekter
Kompilere
Kommerciel
Ledig
Ikke understøttet
IDE
Personer
 Programmeringssprog