Manual de Pascal PDF

Preview

Summary

Apuntes de código cogidos en clase de teoría...

Description

Pascal Estructura básica en Pascal PROGRAM ... ;

{cabecera}

{sección de declaraciones} BEGIN {sentencias} END;

Cabecera: nombre_ programa(input, output); Label: etiquetas (Label 100; | 100: readln(din) | GOTO 100;) Const: declaración de constantes Type: declaración de tipos (nueva variable creada por el usuario) Var: declaración de variable Procedure: subrutina Function: subrutina Caracteres ASCII CHR(n)

-> símbolo

ORD(símbolo)

->

Diferencia de 32 entre mayúsculas y minúsculas Inicialización de variable Declaración: precio: real VALUE 132.34; Entrada: readln(precio); Procedimiento o función: Iniciar(precio); Asignación: precio:= 1150.25; Los comentarios se usan para describir un programa y aclarar su funcionamiento. (*Comentario en Pascal*)

Tipos de datos Simples Ordinales Integer Char Boolean

Enumerados Subrango No ordinales Real Complex Compuestos Array (vector, matriz) Recored (registros) File Set Tipo enumerado No son compatibles con READ ni con WRITE

TYPE Tdias = (lunes,martes,miercoles,jueves...); Tbebidas = (agua,vino,cerveza,leche...);

Tipo subrango Una variable definida se le aplica un rango

TYPE Tdias = 1..100; Tdecadas = -10..10;

Tipo anónimo Es mejor realizarlo en el TYPE

VAR Alimento: (carne,pescado,verdura,legumbres); Edad: (17..25);

Compatibilidad La compatibilidad en Pascal existe por tipos pero por estructuras no. Ej: Nómina

S.Bruto, IRPF, Complementos, S.Líquido

Paga extraordinaria

S.Bruto, IRPF, Complementos, S.Líquido

Nómina y Paga extraordinaria no serían compatibles.

Operadores módulo

mod() **

potencia real

pow()

potencia

abs()

valor absoluto

round() sqr()

elevar al cuadrado

sqrt() exp() ln()

redondeo

raiz cuadrada

exponencial

logaritmo neperiano

cos() sin() trunc() IN

truncar a la parte entera

pertenece

MAXINT HALT

máximo entero

parada de forma segura por un fallo

final de fichero

EOF

EOLN

final de linea

GetTimeStamp

proporciona la fecha y hora del sistema

readstr writestr

cadenas

Prioridad 1

()

not

2

**

pow

3

*

/

div

4

+

-

><

5

=

mod or

<

>

and

and_then

or_else =

in

Formato Write : ancho : decimales

Estructuras Secuencia (asignación…) Selección (If…) Repetición (While…) Cada grupo de instrucciones entre BEGIN y END

IF IF condicion THEN accion_1;

IF condicion THEN accion_1 ELSE accion_2;

IF condicion THEN BEGIN accion_1; accion_2; ... END ELSE accion_3;

IF condicion_1 THEN accion1 ELSE IF condicion_2 THEN accion_2 ELSE accion_3;

CASE CASE (integer,char) OF caso_1,caso_2: accion_1; caso_3: accion_2; OTHERWISE (ninguna de ellas) END;

WHILE

WHILE condicion DO BEGIN accion_1; accion_2; accion_3 END;

Importante en un bucle para no hacerlo infinito: Inicialización Condición Alteración de la condición

REPEAT No es necesario BEGIN END

REPEAT accion_1; accion_2; accion_3 UNTIL condicion;

FOR FOR i:=valor_inicial TO valor_final DO accion_1; (valor_inicial < valor_final)

FOR variable IN conjunto DO accion_1;

FOR i:=valor_inicial DOWNTO valor_final DO BEGIN (valor_inicial > valor_final) accion_1; accion_2; accion_3 END;

Subrutinas PROCEDIMIENTOS PROCEDURE verbo(parametros); (variables con su tipo); (declaraciones) BEGIN (sentencias) END;

Paso por referencia Si una variable de los parámetros que recoge el procedimiento tiene delante VAR PROCEDURE procedimiento_1(VAR x:integer);

recoge la dirección de memoria de la

variable , en cambio sin ella procedimiento_2(x:integer); recoge solamente el valor de la variable, por lo que no la modificaría. Dos ejemplos:

PROGRAMA paso_por_referencia(input,output); VAR x:integer; PROCEDURE cambiar(VAR y:integer); BEGIN y:=1; END; BEGIN x:=0; cambiar(x); writeln('El valor de x es ',x); END.

Devolvería 1

PROGRAMA paso_por_referencia(input,output); VAR x:integer; PROCEDURE cambiar(y:integer); BEGIN y:=1; END; BEGIN

x:=0; cambiar(x); writeln('El valor de x es ',x); END.

Devolvería 0 Parámetros Protegidos No modificar el contenido original al pasar una variable con VAR a un procedimiento. Es una chapuza protected VAR a:integer, protected b:integer

Se usa para que se trabaje con un VAR en la pila de ejecución y que solo se use el valor para ahorrar memoria. Variables locales y globales No usar globales para pasar variables entre procedimientos. Chapuza

FUNCIONES A diferencia de los procedimientos, las funciones devuelven un valor. Existen funciones ya predefinidas

FUNCTION adjetivo(parametros): tipo_de_la_variable_a_devolver; (declaraciones) BEGIN (sentencias) adjetivo:= valor_variable_que_devuelve END;

Recursividad No es ni la más óptima ni la mejor. Emplea la pila de ejecución y satura la memoria al registrar de las funciones a las que se llama. La recursividad indirecta permite emplear un procedimiento o función definida en lineas posteriores:

Procedure Er; Forward

Procedure Ar; BEGIN Er; END; Procedure Er; BEGIN Ar; END;

Datos estructurados ARRAYS Son un número finito de datos del mismo tipo situados en posiciones de memoria consecutiva. Definicion: Vector_notas: {packed} array [1..80] of Real;

Packed es opcional, comprime todo lo posible los datos.

TYPE tVector = array [2..3] of real; (array de tres elementos de ti

po real)

tCadena = packed array [1..100] of char; (para guardar 100 letras) tCuentaCaracteres = array [char] of integer; (cuenta el numero de caracteres de un texto) tDia = (lunes, martes, miercoles, jueves, viernes...) tGastosSemana = array [tDia] of real; (anotar gastos de cada dia de la semana) tColor = (rojo, amarillo, verde...) tImagen = array [tcolor] of boolean; (almacena si un color está o no en una imagen) VAR cadena_2: packed array [1..20] of char; gastos: tGastosSemana; v1,v2: tVector; cadena_1: tCadena;

Los valores de los Arrays deben inicializarse todos juntos o dejarlos sin inicializar. OTHERWISE Se emplea para inicializar el valor del resto de datos de un Array

S = array [1..8] of char VALUE [1..8:'x']; CORRECTO S = array [1..8] of char VALUE [1..3:'x']; INCORRECTO S = array [1..8] of char VALUE 'x';

INCORRECTO

S = array [1..20] of integer VALUE [3:4; 5:10; OTHERWISE 2];

Matrices En Pascal se definen como un Array de Arrays, dando así lugar a matrices. Nos centramos en las de dos dimensiones siendo todo extrapolable a más de dos dimensiones.

TYPE (*Matrices de 3x3 elementos de tipo real equivalentes*)

tfila = array [1..3] of real; tmatriz1 = array [1..3] of tfila;

tmatriz2 = array [1..3] of array [1..3] of real;

tmatriz3 = array [1..3, 1..3] of real;

La forma de trabajar con los elementos de una matriz es la misma que al trabajar con un string o un array simple:

m: array [1..10] of array ['A'..'D'] of integer;

m[4,'D']:= 5; m[7],['A']:= 8;

Los valores de las matrices al igual que pasa con los array se deben inicializar todos o ninguno:

TYPE tmatriz = array[1..3, 1..4] of integer; VAR m1: tmatriz VALUE [1:[1:2;2..4:2]; 2:[1:5; OTHERWISE 4]; 3:[1..4:5]]; m2: tmatriz VALUE [1:[1:1; OTHERWISE 5]; 2:[1,2:3; 3..4:5]; 3:[3,4:2; OTHERWISE 7];

Ejemplo gráfico:

m: array[1..3, 1..3] of integer VALUE [1:[1:0; OTHERWISE 3]; 2..3: [1:4; OTHERWISE 1]];

La matriz m se vería gráficamente :

0

3

3

4

1

1

4

1

1

Operaciones Solo se operan si la definición es la misma ya que Pascal no compara estructuras.

a1,a2: array [1..5] of integer;

a1:=a2;

Esto sería valido

a1: array [1..5] of integer; a2: array [1..5] of integer;

a1:=a2;

Esto no sería valido Las asignaciones es recomendable realizarlas mediante un bucle for. Es recomendable emplear una constante para asignar el tamaño tanto a los arrays como a las matrices para así poder usarla en los bucles y si fuese necesario variarla. Se puede emplear las partículas AND_THEN y OR_ELSE. Con la primera si la condición que le precede no se verifica ya no se comprueba la siguiente. Con la segunda si la

primera condición se verifica la siguiente tampoco se comprueba. Procedimientos y funciones La estructura es la misma, no cambia. Se recomienda usar PROTECTED VAR para evitar duplicar los array en memoria. Existe una forma para recibir un array de una manera genérica, pero este comenzaría en 0 en vez de en 1. (PROTECTED VAR ar: array of integer; tam: integer); Las variables de retorno en las funciones no se pueden usar, hay que utilizar una intermedia para trabajar dentro de la función.

RECORDS Los registros son un tipo estructurado con un número finito de elementos de distinto tipo con un identificador único. Los componentes de un registro de denominan campos y la declaración se debe especificar el nombre y el tipo de los mismos.

TYPE Registro_persona = RECORD DNI: tDNI; Nombre: string(100); NacidoEn: string(100); Casado: boolena; Domicilio: tDomicilio; Hijos: integer; END;

———————————————————————————————————————————————————————— |

DNI |

Nombre |

NacidoEn

|

Casado

|

Domicilio

|

Hijos

———————————————————————————————————————————————————————— tDni

String(100)

Ejemplos:

TYPE tFecha = RECORD anho: 1..2100; mes: 1..12;

String(100)

Boolean

tDomicilio

Integer

|

dia: 1..31; END; tCumpleaños = ARRAY [1..100] OF tFecha; tAsignatura = RECORD nombre: string(100); nota: real; END; tAlumno = RECORD nombre: string(100); notas: ARRAY [1..3] OF tAsignatura; END;

Registros anidados

tcadena50 = string(50); tAlumno = RECORD nombre: tcadena50; padre: RECORD nombre: tcadena50; profesion: tcadena50; END; madre: RECORD nombre,profesion: tcadena50; END;

No se pueden usar fuera del registro tAlumno Asignación

VAR alumno: Registro_persona; BEGIN alumno.DNI:='44456789-X'; alumno.NHijos:= 0; alumno.FechaNac.dia:= 8; alumno.NacidoEn:= 'Carballo';

Inicialización La inicialización, al contrario que con los array, se puede realizar por separado, sin hacerlo con todos los campos.

tFecha = RECORD dia: 1..31; mes: 1..12 VALUE 5; anho: 1900..2100; END; VALUE [dia:1; mes:1; anho: 1920];

WITH DO

TYPE tPersona = RECORD nombre: string(20); padre,madre,hermana,hermano: RECORD nombre: string(20); END; END; VAR persona1: tPersona; BEGIN WITH persona1 DO BEGIN writeln(nombre); writeln(madre.nombre); END; END.

Operaciones La única operación válida es la asignación (:=) y solo es valida si se definen igual. Registros Variantes Estos son registros en los que ciertos campos están condicionados por otros.

tPersona = RECORD nombre, apellidos: string(50);

edad: 0..969; CASE casado: boolean OF true: (nombre_pareja: string(50)); false: (); END;

tForma = (cuadrado, circulo, triangulo) tFormaGeometrica = RECORD area: real; perimetro: real; CASE forma: tForma OF cuadrado: (lado: real); circulo: (radio: real); triangulo: (base: real; altura: real); END;

Procedimientos y funciones Las estructuras es la mismas. Se recomienda usar PROTECTED VAR para recibir un RECORD como parámetro para no tener que realizar una copia del mismo.

FUNCTION Area(PROTECTED VAR df: tFormaGeometrica): real; CONST pi = 3.14... BEGIN WITH df DO CASE forma OF cuadrado: Area:= lado * lado; circulo: Area:= pi * radio * radio; triangulo: Area:= base * altura / 2; END; END;

CADENAS Las cadenas son un tipo de dato estructurado formado por un número finito de elementos

de tipo char con un único identificador. La capacidad es el número máximo de caracteres que se pueden almacenar. La longitud es número de caracteres almacenados realmente. Longitud fija: packed array [1..capacidad] of char (se completa con posiciones en blanco) Longitud variable: string(capacidad) (no se completa con posiciones en blanco) Longitud máxima: 255 (estándar) Se considera la equivalencia estructural, se pueden emplear con distintas definiciones. Funciones longitud de s

length(s)

posición de s2 en s1

index(s1,s2)

subcadena de s que empieza en p y abarca hasta el final

substr(s,p) substr(s,p,n)

subcadena de s que empieza en p y acaba en n

obtiene la cadena s sin espacios al final

trim(s) EQ(s1,s2)

sin son iguales devuelve True

NE(s1,s2)

sin son distintos devuelve True

LT(s1,s2)

sin s1s2 devuelve True

GE(s1,s2)

sin s1≥s2 devuelve True

readstr(s,arg...) writestr(s,arg...)

en vez de leer de teclado lee del string en vez de escribir en pantalla escribe en el storing

Ojo con los string y las longitudes en readstr nombre: string(10) readstr(‘Pedro 1 2.5’,nombre,grupo,nota)

ERROR

CONJUNTOS Los conjuntos son un tipo de dato compuesto por un número finito de elementos todos del mismo tipo ordinal y representar los conjuntos matemáticos. No ocupan una posición determinada y solo se almacena si el dato pertenece o no al conjunto por lo que no admite datos repetidos. |

A

|

B

|

C

|

D

|

E

|

F

|

G

|

|

1

|

1

|

1

|

0

|

0

|

1

|

0

|

CONJ={A,B,C,F}

Definición

TYPE nombre= SET OF tipo {Admite: char, integer, boolean, subrango, enumerado}

Ejemplo:

TYPE tLetras= SET OF char;

{Definición}

VAR letras: tLetras VALUE ['A','B','E'..'G'];

{Inicialización}

BEGIN letras:= letras + ['I'];

{Adición}

END.

Operaciones Los conjuntos admiten 4 operaciones: Union (+) Diferencia (—) Intersección (*) Diferencia simétrica (>...