Pascal (llenguatge de programació)

De la Viquipèdia, l'enciclopèdia lliure.
Saltar a la navegació Saltar a la cerca
Pascal
llenguatge de programació
Autor Niklaus Wirth
Data d’origen 1970
Ús genèric, didàctic
Paradigmes programació estructurada
Escrivint fort, estàtic
Especificacions d'idioma Manual d’usuari i informe de Pascal
Extensions comunes .pas, .inc
Influenciat per ALGOL

Pascal , en informàtica , és un llenguatge de programació creat per Niklaus Wirth i basat en el llenguatge ALGOL ; el nom està dedicat a Blaise Pascal que va inventar la Pascalina el 1645, considerada la primera calculadora.

Història

Sembla que Wirth, professor de programació dels anys seixanta, va sentir la manca d’un llenguatge de programació adequat per ensenyar la seva assignatura i equipat amb estructures de dades avançades. BASIC , creat el 1964 , era fàcil d’aprendre, però no tenia estructures de dades avançades i no animava prou a analitzar el problema abans d’escriure el codi. Fins i tot idiomes com ALGOL i Fortran no semblaven adequats per als seus propòsits didàctics. Per tant, Wirth va crear el llenguatge Pascal des de zero, incorporant el concepte de programació estructurada [1] .

La primera implementació de la llengua va començar a funcionar el 1970 , però va arribar a una bona difusió en el camp industrial a partir del 1974 , amb la publicació del llibre "Pascal User Manual and Report" [2] , considerat la referència estàndard de la llengua. TeX i part de les primeres versions de la Macintosh [3] i Microsoft Windows [4] Sistemes operatius van ser escrits en Pascal.

En ser un llenguatge dissenyat per a estudiants i usuaris sense experiència, els compiladors Pascal tenen una actitud protectora cap al programador (suposant que qualsevol irregularitat en el codi escrit és un error), cosa que sovint molesta una mica els experts. Per exemple, les dades i les funcions són comprovats pel compilador utilitzant l'anomenada tipificació forta (fort comprovació de tipus), o un rigor estreta relació amb la definició i l'ús de tipus de dades, en contrast amb unes llengües tipus febles (per exemple, JavaScript ) que en canvi permeten als programadors experimentats una major llibertat per escriure codi a costa de dificultar la detecció d’errors d’estructura i sintaxi.

Pascal és un llenguatge que requereix tant l’ús d’un bon estil de programació com per analitzar a fons el problema abans de començar a escriure codi font . Donada la difusió en entorns escolars i l’evolució de la tecnologia i les necessitats del mercat, s’han creat versions orientades a objectes, com ara Turbo Pascal i Object Pascal (que s’utilitzen a l’ entorn de desenvolupament Delphi de Borland , ara propietat d’Embarcadero).

Característiques

Les principals característiques de Pascal són una sintaxi clara i rígida amb l’obligació de dividir el programa en seccions ben definides ( uses específics i implementation ) i declarar per endavant totes les variables utilitzades al programa. La seqüència de definició dels elements del codi font també està codificada rígidament i seqüencialment, és a dir: etiquetes, constants, tipus, variables, procediments i funcions ( label , const , type , var , procedure , function) . També permet l’ús de tipus de dades complexos definibles pel programador ( record ) mitjançant l’especificació de la secció de type . També permet l'ús de punters i assignació dinàmica de memòria ( new i dispose les especificacions), d'una manera més controlada, per exemple, que el tradicional llenguatge C .

Pascal es classifica com a llenguatge semidinàmic , ja que gestiona els indicadors , cosa que permet crear llistes de variables de mida desconeguda en el moment de la compilació , però només poden ser d’un tipus a la vegada, el que s’utilitza per definir el punter variable pròpia. En lloc de subrutines , que s’utilitzen habitualment en els primers llenguatges de programació, Pascal introdueix procediments i funcions , que amplien el concepte de subrutines encapsulant variables i dades locals al seu interior. A més, en la seva formulació original, el llenguatge no tenia la instrucció GOTO , conceptualment contrària a la correcta estructuració dels programes, afegida posteriorment, però l'ús del qual és tanmateix desaconsellat.

Compiladors gratuïts

Mostra de programes

Hola món!

L'exemple següent imprimeix el text " Hello world " a la pantalla.

 programa hola ;  
utilitza crt ; <---- no obligatori
començar
  clrscr ; <---- no obligatori
  writeln ( 'Hola món' ) ;
  readln
final .

Notes La primera línia introdueix el programa amb la paraula clau programa , seguit del títol del programa. No es poden utilitzar caràcters i espais especials. La tercera línia conté la sentència begin , que s’utilitza per començar a escriure el programa real. La cinquena línia conté la instrucció writeln , que s’utilitza per escriure el text ("Hello World") que es mostra entre claudàtors a la pantalla, mentre que la sisena, amb la instrucció readln , situa el programa esperant una entrada de teclat, de manera que no faci l’escriptura desapareix immediatament. Quan es prem la tecla d'inici, el programa continuarà executant la sentència final , que finalitza la seqüència. Aquesta ordre és l'única, a l'entorn Pascal, que ha de seguir un punt en lloc d'un punt i coma.


Les variables

Pascal ofereix molts tipus de variables :

  • Tipus d'enters , que s'utilitzen per emmagatzemar valors numèrics enters signats o sense signar dins de determinats intervals numèrics. A Pascal són:
    • integer : variable integer 16 bits signada (números de -32.768 a 32.767)
    • word : variable sencera de 16 bits sense signar, amb valors entre 0 i 65.535.
    • byte : com el seu nom ja indica, aquest tipus ocupa un byte a la memòria i permet diferents valors, de 0 a 255. Aquest tipus és completament compatible amb el tipus de char : l'única diferència és que un tipus de byte té com a visualització per defecte la d'un número, mentre que la char d'un caràcter.
    • short : com l'anterior, només ocupa un byte, però representa els números signats, de manera que els valors poden variar de -128 a 127.
    • longint : ocupa 4 bytes (o 32 bits) i us permet gestionar diversos valors signats, que van des de -2147483648 fins a 2147483647.
    • comp : és el tipus enter més gran. Ocupa 8 bytes (64 bits), per tant permet gestionar diversos valors signats, que van des de -9.2E18 fins a 9.2E18.
  • Tipus reals :
    • real : nombre real signat (números de -2.9E-39 a 1.7E38), que es pot representar en notació científica o exponencial. Si s’introdueixen nombres real des del teclat, s’han d’escriure en notació exponencial. Per imprimir un número real en format decimal, utilitzeu la sintaxi següent:
 ... {Més instruccions}
Var R : Real ;
... {Més instruccions}
Writeln ( "El nombre real és" , R : 10 : 3 ) ;
... {Més instruccions}

En aquest cas, es mostren un total de 10 dígits, dels quals 3 són decimals.

  • Tipus de char ( char ): variable de caràcter, representa un sol caràcter generalment codificat en vuit bits amb format ASCII .
  • Tipus de string ( string ): variable que conté diversos caràcters, de fet és una matriu de caràcters. Per accedir als caràcters individuals continguts en una cadena, simplement utilitzeu els claudàtors [] especificant el número del caràcter a utilitzar (lectura / escriptura). Podeu indicar la longitud màxima de la cadena inserint [n] durant la declaració, si no s'especifica, la longitud serà de 256 caràcters.
  • Tipus booleà ( boolean ): variable binària (vertader / fals).

Punters

Podeu especificar indicadors de variables mitjançant un nom a la declaració seguit del símbol ^ precedeix el tipus de variable cap al qual ha de apuntar el punter. Els indicadors funcionen com en C / C ++ :

 var
  punter : ^ int ;
  número : int ;
començar
  número : = 10 ;
  punter : = número @
final .

D'aquesta manera, el pointer assenyalarà el number . Mentre assignem un valor a l’espai de memòria dirigit pel pointer , utilitzarem ^ al final del nom, és a dir, com a operador de desferenciació :

 punter ^ : = 15 ;

Matriu

Icona de la lupa mgx2.svg El mateix tema en detall: matriu .

Les array Pascal són una seqüència ordenada, en una quantitat predeterminada, d'elements del mateix tipus. Els elements poden estar formats per qualsevol tipus de dades, nadiu o programador definit mitjançant type .

Una característica important del llenguatge Pascal és que quan es declara una array , també es defineix el valor inicial de l’índex que s’utilitzarà per escanejar els diversos elements:

  • Matriu d'un tipus genèric :
 Nom de la variable : array [ inici .. final ] del tipus ;
  • Cadenes : com en molts altres idiomes, les cadenes són simplement matrius de personatges. La declaració d'una variable de cadena és, per tant, la declaració d'una matriu que consisteix en una quantitat predefinida de caràcters. L'exemple següent crea una variable de cadena de 20 caràcters. La variable declarada d'aquesta manera es pot utilitzar com a matriu, és a dir, accedint a la informació caràcter per caràcter o en conjunt. Si utilitzeu una assignació d’aquest darrer tipus, els elements posteriors a la longitud de la cadena literal assignada també es veuran afectats. Així, seguint l'exemple, la matriu rep el nom "Paul" en els seus primers cinc elements, mentre que en els altres s'insereix un espai de totes maneres. No obstant això, en les implementacions Pascal més recents és possible utilitzar el tipus String , que substitueix la array [0.. n ] of char declaracions array [0.. n ] of char
 Nom de la variable : array [ 1 .. 20 ] of char ;
..... {Altres instruccions}
nom : = 'Paolo' ; {assignació en conjunt}
nom [ 5 ] : = 'a' ; {només l'assignació del cinquè caràcter}

Registre

Icona de la lupa mgx2.svg El mateix tema en detall: Registre (tipus de dades) .

A Pascal, podeu definir un tipus personalitzat (personalitzat), estructurat pel propi programador. La sintaxi es basa en l'especificació del type :

 tipus persona = registre
     nom : cadena [ 30 ] ;
     edat : int
final ;

i, a continuació, utilitzeu el tipus de variable personalitzada així:

 var algú : persona ;
començar
    algú . nom : = 'Asdrúbal'
    algú . edat : = 35
final .

Entrada i sortida

L’ entrada de dades des del teclat es fa mitjançant l’ús de l’ readln(nome_variabile) .
La sortida utilitza l'ordre writeln(nome_variabile) ; la serigrafia encara utilitza l'ordre writeln , però el text està entre cometes simples "( writeln('ciao mondo'); )

També hi ha les dues funcions write() i read() que difereixen de les anteriors en què no escriuen un codi de retorn de carro al final de la línia.
Un exemple de E / S sencers:

 programa input_output ( entrada , sortida ) ;
var 
     n1 , n2 , ris : enter ; {Declaració de tipus enter}
començar
     writeln ( 'Insereix n1' ) ; {es mostra el text entre ''}
     readln ( n1 ) ; {ordre d'entrada, la variable introduïda s'insereix a n1}
     writeln ( 'Insereix n2' ) ;
     readln ( n2 ) ;
     ris : = n1 + n2 ; {fa la suma de n1 i n2 i el resultat s'insereix a ris}
     writeln ( "La suma és" igual a " , ris ) ; {imprimeix el missatge entre '' i la variable ris}
     readln {això impedeix que el programa es tanqui sense poder llegir l'última línia, el programa ho farà
espereu que l’usuari escrigui alguna cosa i després premeu ENTRAR. Això farà que el programa es tanqui.}
final .

E / S real: per a l’entrada de nombres reals, el mètode sempre és el mateix ( readln (variable)), en lloc de per a la sortida, per veure nombres comprensibles, heu d’utilitzar una sintaxi diferent a l’ writeln

 programa input_output ( entrada , sortida ) ;
var n1 , n2 , ris : real ; {Declaració de tipus real}
començar
     writeln ( 'Insereix n1' ) ; {es mostra el text entre ''}
     readln ( n1 ) ; {ordre d'entrada, la variable introduïda es posa a n1}
     writeln ( 'Insereix n2' ) ;
     readln ( n2 ) ;
     ris : = n1 + n2 ; {fa la suma de n1 i n2 i el resultat es posa en ris}
     writeln ( "La suma és" igual a " , res : 6 : 2 ) ;  
{imprimeix el missatge entre '' i la variable ris, amb 6 números abans del ",", el "," i 2 després}
     readln
final .

A la serigrafia hem utilitzat una alteració de l'ordre writeln , afegint var: n: m on var és el nom de la variable que es mostrarà, n és el nombre total de dígits (inclòs el ",") que es mostraran i m són els que apareixen després de la coma. Si hi ha més dígits per mostrar que els indicats, no s’enviaran al dispositiu de sortida.

Caràcters d'E / S: l'entrada i sortida de caràcters (números, lletres, símbols) és la mateixa per als caràcters i els enters:

 programa input_output ( entrada , sortida ) ;
var ch : char ; {Declaració del tipus de caràcter}
començar
     writeln ( 'Insereix el caràcter' ) ; {es mostra el text entre ''}
     readln ( ch ) ; {ordre d'entrada, la variable introduïda es posa a ch}
     writeln ( 'El caràcter introduït és ' ' ' , ch ) ; {imprimeix el missatge entre '' i la variable ch}
     readln
final .

Cadenes d'E / S: les variables de cadena com ja s'ha esmentat són array de char (vectors de caràcters).

Estructures de control

Alternatives

 Programa alternatiu ;
var 
   n : enter ;
començar
 escriure ( 'introduïu un número:' ) ;
 readln ( n ) ;
 si n > 0 {comproveu si el valor és positiu}
  llavors
    escriure ( "el nombre és" positiu " )
  en cas contrari
    write ( 'el número és' negatiu ' ) ;
 readln
final .

Iteració

Els fragments de codi següents mostren un exemple de bucles d' iteració en idioma Pascal.

 Programa ciclo_for ;
var i , n , num : enter ;
començar
 write ( 'quants números voleu inserir?' ) ;
 readln ( n ) ;
 per a i : = 1 a n fer
  començar
   write ( 'inserir número:' ) ;
   readln ( num ) ;
  final ;
 readln
final .

Després de l'especificació per a, s'ha d'assignar un valor a una variable (en aquest cas i:=1 ). Aquesta variable s'incrementa automàticament a cada repetició de l'bucle, que és de la codi indicats després for entre fer i end : un cop igual a el nombre (o variable) després de la a, el bucle acabarà.

El valor d'una variable també es pot incrementar utilitzant la mateixa variable que una referència. Obbviament, no hem de confondre aquestes expressions en Pascal i en molts altres idiomes amb les convencions d’equacions matemàtiques.

El bucle for ... to ... do repeteix un bloc d'instruccions un nombre determinat de vegades, per tant, estan prohibits els valors decimals reals abans i després de, i les variables que s'han d'utilitzar sempre han d'estar declarades senceres ( tipus enter ).

També podeu executar un bucle for..to..do en ordre invers, és a dir, del nombre més alt al més baix, utilitzant la paraula clau downto en lloc de to . En aquest cas, a cada repetició del cicle la variable es decrementarà en lloc d’augmentar-la.

 Programa Exemple2 ;
Utilitza Crt , WinDos ;
Var nom1 , nom2 , cadena : cadena ;
 fitxer1 , fitxer2 : text ;
començar
 clrscr ;
 write ( 'Introduïu el nom d'un fitxer:' ) ;
 readln (nom1);
 write ( 'Introduïu el nom del fitxer de còpia:' ) ;
 readln (nom2);
 Assigna ( fitxer1 , nom1 ) ;
 Assigna ( fitxer2 , nom2 ) ;
 Restableix ( fitxer1 ) ;
 Torna a escriure ( fitxer2 ) ;
 repetir
  readln ( fitxer1 , cadena ) ;
  writeln ( fitxer2 , cadena ) ;
 fins a eof ( fitxer1 ) ;
 Tanca ( fitxer1 ) ;
 Tanca ( fitxer2 ) ;
 writeln ( 'La còpia s'ha completat!' ) ;
 readln
final .

Assigna (fitxer1, nom1): aquesta especificació assigna el nom del fitxer contingut a la cadena name1 al fitxer variable 1 de tipus text.

Cal tenir en compte com el llenguatge tradicional Pascal utilitza noms de fitxer. Un nom pot constar d'un màxim de vuit caràcters, excloent l'extensió. Si el nom supera els 8 caràcters, es trunca a 6 i s'afegeix un ~ 1 (el codi ASCII del títol, ~, és 126). Per tant, el nom testouno.txt és correcte i es manté sense canvis. En canvi, testoquattro.txt és incorrecte i el compilador generarà un missatge d' error ( error 2: no s'ha trobat el fitxer ); textq ~ 1.txt és la versió correcta de l'exemple anterior: els caràcters es tallen a 6 i s'afegeixen un ~ 1.

Restableix (fitxer1); : la instrucció reset (x), on x és una variable inicialitzada amb Assign i de tipus text o fitxer, s'utilitza per obrir el fitxer x, a la vista de les operacions de lectura / escriptura.

Torna a escriure (fitxer2); : s'apliquen les mateixes regles de reset . Reescriure (x: text o fitxer) és un procediment que crea un nou fitxer x (si el directori no s'especifica al seu nom, es crea al camí d'accés actual). Si ja existeix un fitxer anomenat x, el sobreescriu.

repetir ... fins a eof (fitxer1); : repeteix un bucle d'afirmacions fins que l'expressió indicada després de until sigui certa. En el nostre cas, el programa continua llegint, línia per línia, cada seqüència de caràcters continguda a file1 i la copia a file2 , fins que la variable de restabliment eof (que vol dir Fi de fitxer; només admet paràmetres de tipus text o fitxer) és true i, per tant, s'ha acabat el fitxer per llegir.

Tanca (fitxer1); : La close procediment tanca un arxiu.

Com hem vist, el until repeat ... until s'utilitza per repetir una sentència o bloc d'afirmacions fins que una condició sigui certa. No cal incloure el bloc de sentències entre un begin i un end , ja que els límits del bloc ja estan definits per repeat i until .

 Exemple de programa3 ;
Utilitza Crt ;
Var x , y : paraula ;
 
començar
 clrscr ;
 write ( 'Introduïu dues coordenades:' ) ;
 readln ( x , y ) ;
 mentre que ( x <> 0 ) i ( y <> 0 ) 
  començar
   llegir ( x , y ) ;
   gotoxi ( x , y ) ;
   escriure (( , x ,;, y , )) ;
  final ;    
 readln
final .

Aquest programa llegeix dues coordenades des del teclat, mou el cursor a les coordenades donades i escriu les abscisses i les ordenades entre parèntesis, separades per un punt i coma, en aquest punt. El cicle es repeteix cada vegada que es compleix la condició indicada: en aquest cas, tant x com y són diferents de 0.

El procediment gotoxy (x, y: word) mou el cursor a les coordenades (x; y) de la pantalla.

Fins i tot amb while és aconsellable prestar atenció a infinits bucles i tingueu en compte que amb while és necessari incloure el bloc d’enunciats entre begin i end ;

Nota

Bibliografia

Articles relacionats

Altres projectes

Enllaços externs

Control de l'autoritat LCCN (EN) sh85098423 · BNF (FR) cb11941547z (data)