EL LENGUAJE DE PROGRAMACIÓN
PASCAL
PEDRO L. GALINDO RIAÑO
EL LENGUAJE DE PROGRAMACIÓN
PASCAL
PEDRO L. GALINDO RIAÑO
Escribir el prólogo de un libro es un compromiso entre la crítica y la amistad; normalmente la amistad prevalece sobre el sentido crítico, y el prefacio escrito resulta ser un elogio sin trabas a la obra de un amigo. Y me parece normal y bueno que sea así. Sería absurdo afinar el lápiz para buscar deficiencias y puntos oscuros en el trabajo de alguien a quien aprecias. Sin embargo, por autodisciplina profesional, quiero resaltar algunos aspectos que creo merecen especial atención:
El primero es la idea de "secuencialidad pedagógica" que envuelve el texto, y que somete al lector a un ritmo cuasi cinematógrafico de aprendizaje. Cada capítulo, cada lección, sigue una línea ascendente, de lo simple a lo complicado, para caer súbitamente otra vez a lo fácil y subir a lo complejo con un ritmo natural y previsto que no dudo facilitará el aprendizaje del lenguaje Pascal de modo rápido y eficiente.
El segundo aspecto a destacar es la "síntesis pedagógica"; en pocas páginas, en una huida premeditada de la pormenorización exagerada, logra una exposición muy completa del Pascal.
Por último, es interesante señalar que los problemas elegidos para ilustrar la teoría no son fruto de una oportunidad casual, sino producto de una cuidadosa selección para lubricar el proceso de aprendizaje.
Por las consideraciones expuestas, espero que el presente libro sirva de estímulo a los alumnos para aprender más, y a Pedro para que se empeñe en otras obras de superior magnitud.
Ignacio Pérez Blanquer.
Cádiz, a 10 de Noviembre de 1993
A Bárbara e Ignacio, por su apoyo y colaboración incondicional.
1.1 El Primer Programa. ... 1
1.2 Identificadores. ... 2
1.3 Palabras Reservadas. ... 4
1.4 Estructura Básica de un Programa. ... 5
1.5 Constantes. ... 6
1.6 Variables. ... 9
1.7 La instrucción de asignación. ... 14
1.8 Instrucciones Elementales de Entrada / Salida. ... 17
1.9 Comentarios. ... 19
1.10 Criterios de Estilo al Escribir Programas. ... 20
1.11 El Primer Programa Completo. ... 21
2. Tipos de Datos Predefinidos. 23
2.1 Introducción. Concepto de Tipo de Datos. ... 232.2 Datos de Tipo Entero. ... 24
2.3 Datos de Tipo Carácter. ... 25
2.4 Datos de Tipo Real. ... 26
2.5 Datos de Tipo Lógico. ... 27
2.6 Expresiones Numéricas. ... 28
2.7 Concepto de Precedencia de Operador ... 30
2.8 Expresiones Booleanas. ... 32
2.9 Operadores Relacionales. ... 34
3. Entrada / Salida. 37
3.1 Sentencias de escritura. ... 373.2 Sentencias de lectura ... 40
3.3 Entrada/Salida formateada de datos numéricos. ... 45
4.4 La estructura IF - THEN - ELSE. ... 52
4.5 La estructura CASE. ... 56
5. Sentencias iterativas (Bucles). 60
5.1 La estructura WHILE-DO. ... 605.2 La estructura REPEAT-UNTIL. ... 63
5.3 La estructura FOR. ... 67
5.4 Anidamiento de Estructuras. ... 71
6. Datos definidos por el Usuario. 74
6.1 Introdución. ... 746.2 Datos de Tipo Enumerado ó Escalares. ... 74
6.3 Datos Ordinales. ... 76
6.4 Datos de Tipo Subrango. ... 77
6.5 Creación de Tipos de Datos Nuevos (Sección TYPE). ... 79
7. Representación interna de Datos. 81
7.1 Introdución. ... 817.2 El Tipo Integer. ... 85
7.3 El Tipo Char. ... 90
7.4 El Tipo Boolean. ... 92
7.5 El Tipo Real. ... 92
7.6 El Tipo Enumerado ... 92
8.4 El Tipo ARRAY Multidimensional. ... 104
8.5 Combinaciones de Datos ARRAY y RECORD ... 109
9. Procedimientos y Funciones. 110
9.1 Introducción. ... 1109.2 Subprogramas. Concepto y Ventajas ... 114
9.3 Procedimientos. ... 116
9.4 Transferencia de Datos ... 119
9.5 Funciones. ... 122
9.6 Paso de Parámetros. (Por Valor/Por Referencia). ... 127
9.7 Proceso físico del paso de parámetros ... 129
9.8 Reglas Generales para el paso de parámetros ... 131
9.9 Variables Locales y Globales. Ámbito de Variables. ... 132
9.10 Buenas Técnicas de Escritura de Subprogramas. ... 133
9.11 Cuadro de Subprogramas Standard de PASCAL. ... 134
10. El Tipo de Datos Puntero. 136
10.1 Representación de variables como <dirección , tipo_asociado , contenido> ... 13610.2 Concepto de puntero. ... 138
10.3 Declaración de punteros. ... 141
10.4 Conceptos de memoria estática y dinámica. ... 143
10.5 La instrucción new ... 145
10.6 La instrucción dispose ... 149
10.7 Operaciones con punteros ... 151
10.8 Utilización de punteros para almacenamiento dinámico de variables. ... 157
11.4 Ficheros Secuenciales. ... 167 11.5 Ficheros de Acceso Directo. Operaciones Adicionales ... 174
1. Introducción
1.1 EL PRIMER PROGRAMA.
PROGRAM PrimerPrograma;
BEGIN
write('Enhorabuena');
END.
PROGRAM
Es la primera palabra de todo programa, y da comienzo al mismo.
PrimerPrograma
Es el nombre del programa. Todo programa tiene un nombre.
;
Es el carácter que se usa en Pascal para separar una instrucción de otra.
BEGIN
Indica la posición de comienzo de las instrucciones que el programa debe ejecutar.
Todo programa debe tener al menos un BEGIN y un END.
write
Es la instrucción de escritura. Todo programa debe tener al menos una instrucción.
'Enhorabuena'
Es una constante que se escribirá en la pantalla cuando ejecutemos el programa.
END.
Indica el final del programa. Todo programa termina con un END.
1.2 IDENTIFICADORES.
Definicion.
Son las palabras de un programa elegidas a gusto del programador.
En el ejemplo anterior, PrimerPrograma es un identificador.
Utilidad.
Dan nombre a todos los elementos definidos por el programador.
Restricciones para que un identificador sea válido.
¡Error! Marcador no definido. Empezar por una letra.
¡Error! Marcador no definido. Ir seguido (opcionalmente) de : Dígitos (0 , 1 , ... 9)
Letras ( A .. Z , a..z )
Hay que considerar con especial cuidado que :
¡Error! Marcador no definido. Algunos compiladores admiten el '_', pero no lo usaremos.
¡Error! Marcador no definido. Sin blancos ni saltos de línea entre medio.
¡Error! Marcador no definido. En general, no se distingue entre mayúsculas y minúsculas.
Esquema sintáctico de un identificador.
Identificador
Letra
Letra Digito
Ejs de identificadores válidos :
CantidadTotal Nombre
NumMuertes Dni Ejs de identificadores inválidos :
Jose Luis (Contiene un espacio)
2Vidas (No comienza por una letra)
tres.personas (Contiene un punto)
Criterios al elegir nombres de identificadores :
¡Error! Marcador no definido. Significativos. ( Que signifiquen aquello que son )
Ejs correctos : NumVidas, Tiempo, Espacio Ejs incorrectos : i0xe4 , A0x , wwww
¡Error! Marcador no definido. Breves, pero conservando el significado. ( Simplifican su escritura )
Ej. correctos : NumVidas
Ej. incorrectos : numerodevidasquequedanhastaelfin
¡Error! Marcador no definido. Uso inteligente de mayúsculas ( Simplifican su lectura )
Ejs. correctos : TasaDePoliza, NumeroDeVidas Ejs. incorrectos : tasadepoliza, numerodevidas
1.3 PALABRAS RESERVADAS.
Definicion.
Son las palabras propias del lenguaje Pascal, y que no pueden ser usadas como identificadores.
Por ejemplo :
PROGRAM indica la línea que da nombre al programa.
BEGIN indica dónde comienza un grupo de instrucciones.
END indica el fin de un grupo de instrucciones.
Y como éstas, algunas más que ya veremos.
Utilidad
Las Palabras reservadas las utiliza el compilador para fines propios, como por ejemplo, saber dónde comienza un programa, dónde termina, etc.
Para mayor claridad, las palabras reservadas las escribiremos siempre en mayúsculas.
Para tener una idea global, diremos que existen un total de 35 palabras reservadas en Pascal, que iremos viendo poco a poco a lo largo del curso.
AND END NIL SET
ARRAY FILE NOT THEN
BEGIN FOR OF TO
CASE FUNCTION OR TYPE
CONST GOTO PACKED UNTIL
DIV IF PROCEDURE VER
DO IN PROGRAM WHILE
DOWNTO LABEL RECORD WITH
ELSE MOD REPEAT
1.4 ESTRUCTURA BÁSICA DE UN PROGRAMA.
PROGRAM nombre_de_programa;
< DESCRIPCION DE DATOS >
BEGIN
< DESCRIPCION DE PROCESOS >
END.
< DESCRIPCION DE DATOS >
En esta zona del programa se definen los datos que el programa va a utilizar.
Estudiaremos en los proximos apartados dos tipos de datos :
Constantes
Variables
< DESCRIPCION DE PROCESOS >
Esta zona se denomina comúnmente Programa Principal, y contiene el conjunto de instrucciones que se realizan cuando ejecutamos el programa.
Para comenzar veremos dos tipos de instrucciones :
La instrucción de Asignación.
Las instrucciones de Entrada / Salida.
1.5 CONSTANTES
Definición.
La característica principal de una constante es que su valor no puede ser cambiado a lo largo del programa.
Para utilizar una constante, hemos de darle un nombre (un identificador).
La declaración de una constante asocia el identificador deseado con una constante. A partir de ese momento, utilizar el identificador asociado a la constante, o utilizar su valor directamente es indiferente.
Por ejemplo, el resultado de ejecutar uno de los programas siguientes es el mismo :
PROGRAM EjConstantes; PROGRAM EjConstantes2;
BEGIN CONST
write(3.1415); NumeroPi = 3.1415;
END. BEGIN
write(NumeroPi);
END.
En este ejemplo, NumeroPi es el nombre de una constante, y 3.1415 es su valor.
Declaración de constantes en Pascal ( CONST ).
Declaración de Constantes.
CONST Identificador = Valor constante ;
Podremos declarar tanta constantes como sean necesarias.
Por ejemplo :
CONST
NumeroPi = 3.141592 ; NumeroE = 2.71 ;
RaizDeDos = 1.41 ; DiasSemana = 7 ; NumMeses = 12 ;
Texto = 'Este es un ejemplo' ; Ubicación de la declaración de constantes en Pascal.
PROGRAM <nombre de programa> ;
CONST
Dato1 = Constante1;
Dato2 = Constante2;
Dato3 = Constante3;
. . .
Datok = Constantek;
BEGIN
Instrucción1;
Instrucción2;
Instrucción3;
. . .
Instrucción-n;
END.
Nombre del programa
Declaración de constantes
Programa Principal.
Utilidad.
¡Error! Marcador no definido. La utilización de constantes produce programas más claros.
Es más claro utilizar en un programa el nombre ConstanteDePlanck que utilizar su valor directamente 6.62E-34.
CONST
ConstanteDePlanck = 6.62E-34 ;
¡Error! Marcador no definido. Tener la posibilidad de cambiar su valor con facilidad.
Supongamos que utilizamos la constante de Planck en múltiples puntos del programa. Si deseamos modificar su valor, bien porque nos hayamos equivocado, bien porque deseemos mayor precisión, únicamente tendremos que cambiar el valor de la constante en la declaración de constantes.
CONST
ConstanteDePlanck = 6.6252E-34 ; Ejemplo.
PROGRAM EjemploConstantes;
CONST
NumeroPi = 3.1415;
BEGIN
write('El valor de PI es ');
write(NumeroPi);
END.
1.6 VARIABLES.
Definición.
Son los datos que pueden variar a lo largo de la ejecución del programa.
Podemos considerar una variable como una caja con un nombre que almacena un cierto dato.
'V' Sexo
21 Edad
3.141592 NumeroPi
El tamaño de la caja dependerá de lo que queramos almacenar en ella. ( un carácter, un número entero, un número real con mucha precisión, etc.)
El dato almacenado puede ser modificado mediante la operación de asignación :=, como se ve a continuación. Veamos un ejemplo :
PROGRAM EjemploVariables1;
VAR
Edad : integer;
BEGIN
Edad := 0;
write(Edad);
writeln;
Edad := 25;
write(Edad);
writeln;
END.
El resultado de ejecutar el programa anterior es el siguiente : 0
25
En todo momento de un programa, cada variable contiene un valor, incluso al comienzo del programa. Por tanto, si escribimos el siguiente programa obtendremos un resultado inesperado :
PROGRAM EjemploVariables2;
VAR
Edad : integer;
BEGIN
write(Edad);
END.
Podríamos obtener algo así : -32543
Declaración de variables en Pascal ( VAR ).
Declaración de Variables.
VAR Identificador : Tipo ;
,
Por ejemplo :
PROGRAM EjemploVariables3;
VAR
Longitud : real;
NumObjetos , NumPeces : integer;
BEGIN
Longitud := 2.35;
NumObjetos := 3;
NumPeces := 4;
writeln(Longitud);
writeln(NumObjetos);
writeln(NumPeces);
END.
Resultaría en la salida siguiente : 2.350000000E+00 3
4
Ubicación de la declaración de variables en un programa.
PROGRAM <nombre de programa> ;
CONST
Dato1 = Constante1;
Dato2 = Constante2;
Dato3 = Constante3;
. . .
Datok = Constantek;
BEGIN
Instrucción1;
Instrucción2;
Instrucción3;
. . .
Instrucción-n;
END.
Nombre del programa
Declaración de constantes
Programa Principal.
VAR
Dato1, Dato2 : Tipo1;
Dato3 : Tipo2;
Dato4, Dato5 : Tipo3;
. . .
Dato-i : Tipo-k;
Declaración de variables
Ejemplo de uso de constantes y variables.
PROGRAM EjConstVar;
CONST
NumeroPi = 3.1415;
VAR
Lado : integer;
BEGIN
write('El numero pi vale ');
write(NumeroPi);
writeln;
Lado := 10;
write('El lado vale ');
write(Lado);
writeln;
Lado := 25;
write('Ahora, el lado vale ');
write(Lado);
END.
Resultado :
3.14150000E+00 El Lado vale 10
Ahora, el lado vale 25
1.7 LA INSTRUCCIÓN DE ASIGNACIÓN.
Definición.
Es la instrucción que permite almacenar un dato en una variable. Es la instrucción utilizada con mayor frecuencia del Pascal. Veamos un ejemplo :
PROGRAM EjAsignacion1;
CONST
NumeroPi = 3.1415;
VAR
Lado, AreaCuadrado : real;
Radio, Circunferencia : real;
BEGIN
Lado := 10;
AreaCuadrado := Lado * Lado;
Radio := Lado;
Circunferencia := 2 * NumeroPi * Radio;
write(AreaCuadrado, Circunferencia);
END.
Por tanto, el dato que se almacena en la variable puede ser :
¡Error! Marcador no definido. Un valor constante.
Lado := 10;
¡Error! Marcador no definido.Una constante. Por ejemplo, si queremos calcular el área del cuadrado de lado igual a NumeroPi, haríamos lo siguiente :
Lado := NumeroPi;
¡Error! Marcador no definido. Una variable.
Radio := Lado;
¡Error! Marcador no definido. El resultado de una expresión. Una expresión es el resultado de operar diversas variables y constantes entre sí.
Circunferencia := 2 * NumeroPi * Radio ;
Formato.
Instrucción de asignación.
Variable Expresión ;
Modo de Operación.
¡Error! Marcador no definido.1. Evaluar la expresión que haya a la derecha del signo := , obteniendo un valor.
¡Error! Marcador no definido.2. Almacenar dicho valor en la variable que hay a la izquierda del signo := .
Ejemplos.
Radio := 4;
Area := Pi * Radio * Radio;
Diametro := Radio + Radio;
Diametro := 2 * Radio;
Frase = ' El area es ';
Veamos un caso algo peculiar. ¿ Cuál sería el resultado de ejecutar el programa siguiente ? :
PROGRAM EjAsignacion2;
VAR
Radio : integer;
BEGIN
Radio := 4;
Radio := Radio + 1;
write('El valor del radio es ');
write(Radio);
END.
El proceso seguido sería el siguiente :
Almacenar 4 en la variable Radio
Evaluar Radio + 1, obteniendo el valor 5.
Almacenar el valor 5 en la variable Radio.
Imprimir los resultados.
Por tanto, la salida del programa sería : El valor del radio es 5
1.8 INSTRUCCIONES ELEMENTALES DE ENTRADA / SALIDA.
La instrucción write
Permite escribir datos en la pantalla del ordenador.
Podemos escribir :
El resultado de evaluar una expresion. (Constantes, variables, etc.)
Los resultados de evaluar diferentes expresiones, separándolas mediante comas.
Por ejemplo, el trozo de programa siguiente :
PROGRAM EjWrite;
VAR
Lado, Area : integer;
BEGIN
write(5);
write(5,3,2);
writeln;
Lado := 10;
Area := Lado * Lado;
write('Si el lado de un cuadrado es ', Lado);
write(', el area es ', Area);
END.
Resultado : 5532
Si el lado de un cuadrado es 10, el area es 100 ( Observar que al escribir un programa, se pueden incluir espacios o saltar una línea en cualquier sitio, excepto en medio de una constante o de un identificador )
La instrucción writeln
Realiza un salto al comienzo de la línea siguiente.
Por ejemplo :
PROGRAM EjWriteln1;
BEGIN
write(5);
writeln;
write(6) END.
Resultado 5 6
La instrucción read
Permite almacenar en una variable un valor que el usuario introducirá mediante el teclado del ordenador. Se puede leer :
El valor de una variable.
Los valores de varias variables, si las separamos entre comas.
Ej :
read(Radio);
read(Largo, Ancho, Alto);
Veamos un ejemplo práctico:
PROGRAM EjWriteRead1;
VAR
Largo, Ancho, Alto, Volumen : integer;
BEGIN
write('Escribe el largo, ancho y alto : ');
read(Largo, Ancho, Alto);
Volumen := Largo * Ancho * Alto ; write('El volumen es ');
write(Volumen);
END.
1.9 COMENTARIOS.
Definición.
Son explicaciones que incluímos en el programa para aclarar, comentar, etc. lo que hace el programa en cada momento.
No tienen efecto alguno sobre la ejecución del programa. Simplemente sirven para que facilitar la comprensión del programa a toda persona que pueda necesitar leerlo.
Restricciones.
Pueden ir en cualquier punto del programa, salvo en mitad de un identificador o palabra reservada.
Formato.
Comentario
Comentarios
(* *)
Por ejemplo :
(* Esto es un comentario *) También se admite el uso de { }. Por ejemplo : { Este es otro comentario } Utilización.
Deben indicar qué se hace en cada momento, no cómo se hace.
De gran utilidad cuando otras personas lean nuestro programa.
Deben aclarar puntos confusos.
No se deben poner comentarios inútiles. Por ejemplo : i := i + 1;
(* incrementa i en una unidad *)
1.10 CRITERIOS DE ESTILO AL ESCRIBIR PROGRAMAS.
A la hora de realizar un programa con un cierto estilo, hemos de considerar diferentes cuestiones :
Selección correcta de identificadores. (Significativos, Breves, Bien Escritos)
Escritura en mayúsculas de palabras reservadas. (Por claridad)
Utilización de constantes ( Siempre que se considere conveniente )
A ser posible, escribiremos una única instrucción en cada línea del programa.
Uso abundante de comentarios, pero no indiscriminado. Un defecto de comentarios produce programas mal explicados. Un exceso produce dificultad a la hora de diferenciar las instrucciones de los comentarios.
Endentación : consiste en desplazar determinadas instrucciones hacia la derecha (por ejemplo, 3 posiciones), y permite que los programas sean más claros y legibles. Por supuesto, cuanto mayor y más complejo es el programa, mayor importancia adquiere una correcta endentación.
1.11 EL PRIMER PROGRAMA COMPLETO.
PROGRAM DatosCirculo;
(* *********************************************
* El siguiente programa lee el valor del * * radio de un círculo, y calcula la longi- * * tud de la circunferencia y el área del * * círculo correspondientes. * ********************************************* *) CONST
NumeroPi = 3.14159;
VAR
Radio, Circunferencia, Area : real;
BEGIN
(* **************** *) (* Lectura de datos *) (* **************** *)
write(' Escribe el valor del Radio : ');
writeln;
read(Radio);
(* *********************** *) (* Realización de calculos *) (* *********************** *)
Circunferencia := 2 * NumeroPi * Radio;
Area := NumeroPi * Radio * Radio;
(* ******************** *) (* Salida de resultados *) (* ******************** *) write('Radio = ', Radio);
writeln;
write('Circunferencia = ', Circunferencia);
writeln;
write('Area = ', Area);
END.
Observemos el mismo programa, pero escrito de forma absolutamente incorrecta.
( Curiosamente, los resultados obtenidos por ambos programas son los mismos)
program aaa;
var r, c, a : real;begin
write(' Escribe el valor del Radio : ');
read(r); c:= 2 * 3.1415 * r;
area := 3.1415 * r * r;
write('Radio = ', r);writeln;
write('Circunferencia = ', c);
writeln;write('Area = ',a);end.
Por tanto, no sólo es importante que un programa "funcione", sino que además debe ser escrito siguiendo unas ciertas normas que aumenten su claridad y permitan su comprensión.
2. Tipos de Datos Predefinidos
2.1 INTRODUCCIÓN. CONCEPTO DE TIPO DE DATOS.
Un Tipo de Datos está formado por un conjunto de datos con unas características comunes.
Por ejemplo, los números complejos, los números romanos, las letras, los colores, las matrículas de coches...Cada uno de estos grupos comparten una serie de propiedades:
Comparten la representación.
Comparten las operaciones válidas sobre ellos.
Operaciones válidas sobre un tipo de datos no siempre son posibles sobre otro tipo de datos. Por ejemplo, no tiene sentido sumar dos letras, aunque puede tener sentido sumar dos colores. Sin embargo, si queremos sumar dos colores, hemos de tener bien definida la operación "suma de colores". Incluso operaciones con el mismo nombre aplicadas a datos de tipos diferentes tienen efectos diferentes (Por ejemplo, no es lo mismo el módulo de un número complejo que el módulo de un número entero).
Por tanto, a la hora de utilizar un dato de un cierto tipo, es importante conocer en todo momento qué operaciones están permitidas sobre dicho tipo de datos, y tenerlas perfectamente definidas. Por ello un Tipo de Datos se define mediante :
A) Un conjunto de valores :
Aquellos que pueden tomar todos los elementos que pertenezcan a dicho Tipo de Datos.
B) Un conjunto de operaciones :
Aquellas que es posible realizar sobre sus elementos.
2.2 DATOS DE TIPO ENTERO.
Concepto de dato entero.
Los números enteros son el ..., -3 , -2 , -1 , 0 , 1 , 2 , 3 , ...
Digito
Dato INTEGER
Los datos enteros se declaran como integer, y almacenan números enteros.
Operaciones aritméticas básicas con enteros.
Suma A + B
Producto A * B
Resta A - B
División entera A div B (Cociente de la división) Resto de la división A mod B (Resto de la división)
Funciones Básicas con enteros.
Elevar al cuadrado sqr(A) Valor absoluto abs(A)
NOTA : Observar la similitud de las funciones con el término matemático de función :
y = f ( x )
2.3 DATOS DE TIPO CARACTER.
Concepto de carácter.
Los caracteres son :
Las letras minúsculas. 'a'..'z'
Las letras mayúsculas. 'A'..'Z'
Los dígitos. '0'..'9' ( No confundir con los números 0 .. 9 )
Los caracteres especiales : espacio, punto, coma, punto y coma, comillas, subrayado, etc.
Otros caracteres.
Se escriben entre comillas simples.
Ejs : 'a' 'F' ' ' ':' '7'
Dato CHAR
Cualquier ' carácter
sencillo
'
Los datos de tipo carácter se declaran como CHAR, y almacenan caracteres.
Operaciones con caracteres.
No tienen sentido.
Funciones Básicas con caracteres.
succ(c) Devuelve un carácter, que es el sucesor del dado.
pred(c) Devuelve un carácter que es el predecesor del dado.
Ej :
succ('c') = 'd' pred('C') = 'B'
2.4 DATOS DE TIPO REAL.
Concepto de dato REAL.
Los números reales son, por ejemplo :
-1.2543
-1.75e-3 que se corresponde con 1 75 10. 3 0.23e3 que se corresponde con 0 23 10. 3 230
Digito
Número Real
Digito
Digito
Los datos reales se declaran como REAL, y almacenan números reales.
Operaciones aritméticas básicas con reales.
Suma A + B
Producto A * B
Resta A - B
División A / B
Funciones Básicas con reales.
Elevar al cuadrado sqr(A) Valor absoluto abs(A) Seno sin(A)
Coseno cos(A)
Logaritmo Neperiano ln(A) Exponenciación exp(A) Raíz cuadrada sqrt(A)
2.5 DATOS DE TIPO LÓGICO.
Concepto de dato lógico (booleano).
Los valores lógicos son TRUE (que significa cierto) y FALSE (que significa falso).
TRUE
Dato Boolean
FALSE
Los datos booleanos se declaran como BOOLEAN, y solamente pueden almacenar valores lógicos, es decir, TRUE ó FALSE.
Operaciones básicas con datos booleanos.
AND Operador lógico de conjunción.
OR Operador lógico de disyunción.
NOT Operador lógico de negación.
Los operadores lógicos se definen según las siguientes tablas :
A B A AND B A OR B
TRUE TRUE TRUE TRUE TRUE FALSE FALSE TRUE FALSE TRUE FALSE TRUE FALSE FALSE FALSE FALSE
A NOT A
TRUE FALSE FALSE TRUE
2.6 EXPRESIONES NUMÉRICAS.
Concepto de Expresión.
Una expresión es una agrupación sintácticamente correcta de . . .
Operandos
Valores constantes (5, 'a', 13.4, etc.)
Constantes (NumeroPi, ConstanteDePlanck, etc.)
Variables (Radio, Lado, etc.)
Funciones (sqr(5), abs(Radio), etc. )
Operadores
Aritméticos
Lógicos
Relacionales
etc.
. . . que permiten obtener un resultado.
Concepto de Expresión Entera.
Es una expresión de resultado entero. Por ejemplo : 3 * Radio
12 + Radio * 2 NumLados div 4
NumLados div ( Radio * abs(-3) ) 12 * abs(Radio)
Concepto de Expresión Real.
Es una expresión de resultado real. Por ejemplo : 3.0 * Longitud
(12.0 + Longitud ) * sqrt ( 2.0 ) Longitud / sin(4.0)
12.0 * abs(Longitud)
Concepto de Expresión Numérica.
Es una expresión de resultado entero o real.
Normas básicas de construcción de expresiones numéricas.
Si todos los operandos y todos los operadores de una expresión son enteros, el resultado es entero. Por ejemplo :
5 + (2 div 4) * 3 mod 5 - 1
Todo dato real en una expresión correcta puede ser sustituído por un dato entero, y la expresión resultante sigue siendo correcta. Por ejemplo :
Si la expresión 3.5 + 2.0 * sqrt(4.3) es una expresión correcta, también es correcta 3.5 + 2.0 * sqrt(4)
Normalmente, si existe algún operando real no afectado por una función( ya sea una constante, una variable, una función, etc. ), el resultado es real. Por ejemplo :
3 + 2.0 es una expresión real, y vale 5.0 3 * abs(-3.2) es una expresión real, y vale 9.6
2.7 CONCEPTO DE PRECEDENCIA DE OPERADOR.
La precedencia entre operadores establece qué operaciones se realizan antes que otras.
Ejemplo 1 : 3 + 2 * 4
El orden correcto de cálculo es : 3 + 2 * 4
3 + 8
11
En este caso, se dice que el producto precede a la suma, porque primero se realizan los productos, y luego las sumas.
Ejemplo 2 : 3 + 2 * 4 - 2 + 3 * 2 El orden correcto de cálculo es :
3 + 2 * 4 - 2 + 3 * 2 3 + 8 - 2 + 3 * 2 3 + 8 - 2 + 6 11 - 2 + 6 9 + 6
15
Como vemos, en caso de igualdad de precedencia, los cálculos se realizan de izquierda a derecha.
Uso de paréntesis.
Permiten establecer el orden de cálculo de expresiones, diferente del establecido por la precedencia de los operadores implicados en una expresión.
Ejemplo 1 : ( 3 + 2 ) * 4 - 2 El orden correcto de cálculo es :
( 3 + 2 ) * 4 - 2 5 * 4 - 2
20 - 2
18
Ejemplo 2 : ( 3 + 2 ) * (4 - 2) El orden correcto de cálculo es :
( 3 + 2 ) * (4 - 2) 5 * (4 - 2)
5 * 2
10
Precedencia de operador en expresiones numéricas.
1. Paréntesis
2. * , div , / , mod 3. + , -
Por tanto, primero se operan las expresiones entre paréntesis, luego los productos y divisiones, y por último las sumas y restas.
2.8 EXPRESIONES BOOLEANAS.
Concepto de Expresión Booleana.
Una expresión se dice booleana si da un resultado booleano, o sea, si es cierta o falsa.
Por ejemplo :
PROGRAM ExpresionesBooleanas;
VAR
Dato1, Dato2, Dato3 : boolean;
BEGIN
Dato1 := TRUE;
Dato2 := FALSE;
Dato3 := TRUE;
writeln( ( Dato1 AND Dato2 ) OR Dato3 );
writeln( NOT ( Dato1 OR Dato2 ) AND Dato3 );
END.
Precedencia de operador en expresiones booleanas.
1. Paréntesis
2. NOT
3. AND , OR
Se pueden comprobar, realizando las correspondientes tablas de verdad, las siguientes afirmaciones :
NOT (A OR B) = (NOT A) AND (NOT B) NOT (A AND B) = (NOT A) OR (NOT B) NOT (NOT A) = A
A AND (B OR C) = (A AND B) OR (A AND C) A OR (B AND C) = (A OR B) AND (A OR C)
Por ejemplo, comprobemos que se cumple la relación :
NOT (A OR B) = (NOT A) AND (NOT B)
Para ello obtendremos la tabla de verdad de NOT (A OR B), y la tabla de verdad de (NOT A) AND (NOT B), y verificaremos su igualdad o desigualdad.
A B A OR B NOT(A OR B)
TRUE TRUE TRUE FALSE
TRUE FALSE TRUE FALSE
FALSE TRUE TRUE FALSE
FALSE FALSE FALSE TRUE
A B NOT A NOT B (NOT A) AND NOT B)
TRUE TRUE FALSE FALSE FALSE
TRUE FALSE FALSE TRUE FALSE
FALSE TRUE TRUE FALSE FALSE
FALSE FALSE TRUE TRUE TRUE
2.9 OPERADORES RELACIONALES.
Con gran frecuencia se utilizan en programación expresiones del tipo : Radio > 100
que puede dar los siguientes resultados :
TRUE , si el Radio es mayor que 100
FALSE , si el Radio es menor o igual que 100
Tanto Radio como 100 son variables enteras, sin embargo, el resultado es booleano.
Introducimos aquí lo que se llaman operadores relacionales :
Mayor que ...
Menor que ...
Mayor o igual que ...
Menor o igual que ...
Igual que ...
Distinto de ... Los operadores relacionales permiten operar datos no necesariamente de tipo booleano, y obtienen siempre un resultado booleano.
Si lo que hay a la derecha de un operador relacional es de tipo numérico (INTEGER ó REAL) (ya sea una variable, una constante, una expresión, etc.), lo que hay a la derecha también debe ser de tipo numérico.
3.0 < (5 + 2) Resultado = TRUE
Si Radio contiene el valor 2, entonces,
( Radio + 4.0 ) > 12 Resultado = FALSE
Se pueden aplicar los operadores relacionales a datos de tipo CHAR, y tiene el sentido siguiente :
'a' < 'b' < 'c' < ... ... 'y' < 'z' 'A' < 'B' < 'C' < ... ... 'Y' < 'Z'
Si lo que hay a la izquierda de un operador relacional es de tipo CHAR (ya sea una variable, una constante, una expresión de resultado carácter, etc.), lo que hay a la derecha también debe ser de tipo CHAR.
'a' < 'v' Resultado = TRUE
Si Letra contiene el valor 'F', entonces,
Letra > 'T' Resultado = FALSE
Aunque es posible utilizar operadores relacionales con datos de tipo BOOLEAN, no tiene mucho sentido.
Es peligroso muy utilizar los operadores = y <> con datos de tipo real, ya que éstos se almacenan de forma aproximada. Ello nos puede llevar a sorpresas.
El siguiente programa da una muestra de ello : PROGRAM EjReales;
VAR
a,b :real;
BEGIN
a := 1E13;
b := a+1;
IF (a=b) THEN
writeln(´a y b son iguales') ELSE
writeln('a y b son diferentes');
END.
Si se ejecuta el programa se llega a la conclusión que a y b son iguales.
Como en toda expresión, se pueden utilizar paréntesis para agrupar operaciones relacionales. Por ejemplo :
( (A>B) AND (C<>D) ) OR E
En caso de duda, utilizar paréntesis. Por ejemplo, es mejor usar la primera expresión que la segunda, aunque el resultado es idéntico.
( (NOT A) OR B ) AND ( NOT C ) NOT A OR B AND NOT C
NOTA : conviene no agrupar demasiadas operaciones relacionales en una sola instrucción, ya que resulta muy dificil comprender su significado.
Se pueden comprobar fácilmente las siguientes afirmaciones : NOT (A < B) = (A >= B)
NOT (A > B) = (A <= B) NOT (A = B) = (A <> B) NOT (A <= B) = (A > B) NOT (A >= B) = (A < B)
Es interesante notar que el resultado de una expresión con resultado boolean puede ser asignada a una variable boolean. Por tanto, es correcto realizar:
PROGRAM prueba;
VAR
Condicion : Boolean ; Radio : Integer ; BEGIN
write('Escribe un número mayor que 5') ; readln(Radio) ;
Condicion := (Radio>5) ; writeln(Condicion) ; END.
Precedencia de operadores en Pascal.
Una vez estudiados todos los operadores (salvo el operador IN), incluímos a continuación la lista completa de precedencia de operadores en Pascal.
1. Paréntesis.
2. NOT
3. * / DIV MOD AND 4. + - OR
5. = <> < <= > >= IN
3. Entrada / Salida
3.1. SENTENCIAS DE ESCRITURA.
Permiten escribir en la pantalla resultados de una o varias expresiones separadas entre sí por comas. Por tanto, permiten escribir :
Valores Constantes.
Constantes.
Valores de variables.
Resultados de Expresiones.
Cualquier combinación de éstos separados por una coma entre sí.
Existen dos instrucciones de escritura :
La instrucción write
Escribe datos en la línea actual. La siguiente lectura o escritura se harán en la misma línea, justo a continuación del último dato escrito y/o leído.
Ejemplo :
PROGRAM EjWrite1;
VAR
Lado : integer;
BEGIN
Lado := 2;
write(Lado);
write('El lado vale ', Lado);
END.
Salida en pantalla :
2El lado vale 2
La instrucción writeln :
1. writeln sin parámetros : su efecto es simplemente saltar al comienzo de la línea siguiente.
PROGRAM EjWriteln1;
VAR
Lado, Area : integer;
BEGIN
Lado := 2;
Area := Lado * Lado;
write( 'El lado vale ' , Lado);
writeln;
write('El area vale ', Area ) ; END.
Salida en pantalla :
El lado vale 2 El area vale 4
2. writeln con parámetros : su efecto corresponde a realizar una instrucción write con los mismos parámetros seguida inmediatamente por una instrucción writeln sin parámetros.
writeln(a,b,...n);=
write(a,b,...n);
writeln;
PROGRAM EjWriteln2;
VAR
Lado : integer;
BEGIN
Lado := 2;
Area := Lado * Lado;
writeln('El lado vale ',Lado);
writeln('y el area vale ', Area) ; END.
Salida en pantalla : 5
2
El lado vale 2 y el area vale 4
Observamos las siguientes características en los procedimientos de escritura :
A) Si queremos que exista un espacio entre un dato y otro, hemos de especificarlo en la correspondiente instrucción de escritura.
B) El efecto de las siguientes instrucciones es el mismo : Caso 1 :
write('Lado = ', Lado ,' y el area vale ', Area);
Caso 2 :
write('Lado = ') ; write( Lado ) ;
write(' y el area vale ' ) ; write(Area) ;
C) El efecto de las siguientes instrucciones es el mismo : Caso 1 :
writeln(' El lado vale ', Lado );
writeln(' y el area vale ' , Area) ;
Caso 2 :
write(' El lado vale ') ; write( Lado ) ;
writeln;
write(' y el area vale ' ) ; write(Area) ;
writeln;
3.2. SENTENCIAS DE LECTURA
Permiten leer de teclado únicamente valores de variables. (Si queremos leer más de una variable, las separaremos entre sí con comas).
Por tanto, no es posible leer :
Constantes.
read(5) --> error
Valores de datos constantes.
read(NumeroPi) --> error
Expresiones.
read(2*Radio) --> error
Existen dos instrucciones de lectura :
La instrucción read
Lee datos de la línea actual. Por tanto, la siguiente lectura o escritura se harán en la misma línea, justo a continuación del último dato escrito y/o leído.
Ejemplo :
PROGRAM EjRead1;
VAR
Lado : integer;
BEGIN
write('Escribe el Ancho y el Alto : ');
read(Ancho);
read(Alto);
writeln;
writeln('El Ancho vale ', Ancho);
writeln('El Alto vale ', Alto);
END.
Entrada/Salida en pantalla
Escribe el Ancho y el Alto : 2 5 El Ancho vale 2
El Alto vale 5
La instrucción readln
1. readln sin parámetros : su efecto es simplemente realizar una pausa. Cada vez que el programa encuentra un readln sin parámetros espera a que el usuario pulse la tecla ENTER del teclado. Cualquier otra acción del usuario es ignorada.
PROGRAM EjReadln1;
BEGIN
write('Pulsa intro :');
readln;
write('Pulsa Intro de nuevo');
readln;
END.
2. readln con parámetros : su efecto corresponde a realizar una instrucción read con los mismos parámetros seguida inmediatamente por una instrucción writeln sin parámetros.
readln(a,b,...n); =
read(a,b,...n);
writeln;
Lee datos de la línea actual, y a continuación salta una línea, posicionándose al comienzo de la línea siguiente. Por tanto, la siguiente lectura o escritura se harán justo al comienzo de la nueva línea.
Consejos para realizar la entrada de datos.
La utilización de varias variables en las órdenes de lectura, así como una mala utilización de los saltos de línea puede llevar a programas en los que los errores de la introducción de los datos por parte del usuario son elevados.
Por tanto, vamos a establecer unas normas básicas que seguiremos en cada orden de lectura :
Sacar un mensaje indicando qué dato se le solicita a la persona que está al teclado, utilizando una sentencia write.
Leer dicho dato con una sentencia readln.
Realizar estos pasos con cada dato necesario.
Se recomienda realizar una instrucción readln por cada dato necesario.
Realizaremos un ejemplo utilizando esta normativa.
Ejemplo :
PROGRAM EjWriteRead;
VAR
Largo, Ancho, Alto, Volumen : integer;
BEGIN
write('Escribe el largo: ');
readln(Largo);
write('Escribe el ancho: ');
readln(ancho);
write('Escribe el alto: ');
readln(Alto);
Volumen := Largo * Ancho * Alto ; write('El volumen es ');
write(Volumen);
END.
Limitaciones en la lectura de datos.
El formato de cada dato introducido debe cumplir las reglas de sintaxis correspondientes a su tipo.
El número y tipo de las variables introducidas al ejecutar el programa deben corresponderse de forma EXACTA con el número y tipo de las variables especificadas en la instrucción de lectura. De otro modo pueden ignorarse algunos datos o producirse una situación de error.
Ejemplo : Sea Letra una variable de tipo CHAR, y Radio de tipo INTEGER : PROGRAM prueba;
VAR
Letra : Char;
Radio : Integer;
BEGIN
readln(Letra, Radio);
writeln('El valor de Letra es ', Letra) ; writeln('El valor de Radio es ', Radio) ; END.
Si queremos leer desde el teclado dichos datos, podemos escribir : a5
y obtendremos la siguiente salida : El valor de Letra es a El valor de Radio es 5
Las variables de tipo CHAR se leen caracter a caracter, sin saltarse ningun caracter, ya sea letra, dígito, blanco, punto, coma, etc. que haya en la línea de entrada.
Las variables de cualquier otro tipo diferente de CHAR se leen separándolas entre sí por medio de espacios.
Una instrucción readln aislada detiene la ejecución del programa hasta que pulsamos la tecla <INTRO> del teclado.
3.3. ENTRADA/SALIDA FORMATEADA DE DATOS NUMÉRICOS.
Permite determinar a voluntad del programador el número de posiciones reservadas para cada valor numérico (enteros y reales), tanto en instrucciones de escritura como de lectura.
El formato para los números enteros es :
<Nombre de Variable> : NUMERO DE POSICIONES TOTALES
La mejor forma de estudiar su utilización es por medio de ejemplos :
Supongamos que Radio vale 12, y ejecutamos las instrucciones indicadas.
PROGRAMA SALIDA
write('r=',Radio); r=12 write('r=',Radio:2); r=12
write('r=',Radio:3); r= 12
write('r=',Radio:10); r= 12 Es decir, se reservan tantas posiciones para un dato como se indiquen.
De igual forma, si ejecutamos la instrucción :
read(Largo:2,Ancho:1);
writeln('Largo = ' , Largo:4 );
writeln('Ancho = ' , Ancho:3);
E introducimos por teclado 564
Obtenemos una salida igual a : Largo = 56 Ancho = 4
Cuando los números son reales, hemos de indicar además la precisión, es decir, el número de posiciones decimales.
El formato para los números reales es :
<Nombre de Variable> : POSICIONES TOTALES : POSICIONES DECIMALES
Por ejemplo :
writeln('PI = ' , NumeroPi:8:4);
writeln('PI = ' , NumeroPi:7:2);
writeln('PI = ' , NumeroPi:7:5);
Obtenemos una salida igual a : PI = 3.1415 PI = 3.14 PI = 3.14159
4. Sentencias Condicionales
4.1 INTRODUCCION A LOS DIAGRAMAS DE FLUJO (ORGANIGRAMAS )
Hasta ahora, todos los programas eran lineales. Se ejecutaba una instrucción tras otra.
En esta lección se introduce la posibilidad de romper dicho flujo lineal del programa.
Para mayor claridad, vamos a utilizar los diagramas de flujo, que permiten representar en un dibujo todas las alternativas posibles de ejecución de un programa.
Aunque es posible utilizar los diagramas de flujo para diseñar y escribir programas, únicamente los utilizaremos para mostrar de forma didáctica los efectos de instrucciones complejas.
Un diagrama de flujo consta de una serie de elementos, de los cuales, destacamos por su mayor frecuencia de uso los siguientes :
A) Un Ovalo de comienzo.
Indica el comienzo del programa.
Inicio
B) Un Ovalo de fin.
Indica el fin del programa.
Fin
C) Rectángulo
Indica una instrucción o una serie de instrucciones consecutivas simples. Solo deben inluir asignaciones y llamadas a procedimientos (que ya veremos).
Base := 5 ;
Area := (Base * Altura ) / 2 ; Altura := 2 ;
D) Rombo
Será siempre será una expresión boolean. Más adelante veremos su uso.
i > 5
E) Flechas
Indica el flujo de ejecución posible.
4.2. LA ESTRUCTURA BEGIN - END
Definición.
Es la instrucción estructurada más sencilla. Permite agrupar varias instrucciones entre sí, de tal forma que a efectos sintácticos se comportan como una instrucción simple.
Es decir, que puede ir en el mismo lugar que ocupe cualquier otra instrucción, siendo el programa que se obtiene sintácticamente correcto.
Formato.
BEGIN
<instrucción 1>;
<instrucción 2>;
...
<instruccion-k>
END;
Como vemos, el Programa Principal de todo programa está formado por un bloque BEGIN-END, seguido de un punto, que indica el fin del programa.
Diagrama sintáctico.
END
Bloque BEGIN-END
BEGIN Instrucción ;
Ej :
BEGIN
i := 5;
writeln(i);
END;
4.3. LA ESTRUCTURA IF - THEN.
¡Error! Marcador no definido. Definición.
La estructura IF-THEN permite ejecutar (o no) una instrucción, dependiendo del resultado de una expresión booleana.
A) Si la expresión booleana es TRUE, la instrucción se ejecuta.
B) Si la expresión booleana es FALSE, la instrucción no se ejecuta.
¡Error! Marcador no definido. Formato.
IF <expr. booleana> THEN <instrucción>;
¡Error! Marcador no definido. Diagrama de flujo.
Expresion Booleana
Instrucción True
False
¡Error! Marcador no definido.Como podemos deducir del diagrama de flujo, en una estructura IF-THEN, no siempre se ejecuta la instrucción.
¡Error! Marcador no definido.Como hemos comentado, la instrucción a ejecutar puede ser un bloque BEGIN-END, por lo que tendremos la siguiente estructura :
IF <expr. booleana> THEN BEGIN <instrucción1>;
<instrucción2>;
...
END;
Ejemplo : Realizar un programa que lea un número real y lo imprima si es mayor de 10.
PROGRAM EjIf1;
VAR
Numero : real;
EsMayor : boolean;
BEGIN
write('Escribe un número real : ');
readln(Numero);
EsMayor := ( Numero > 10 );
IF EsMayor THEN write(Numero);
END.
Ej. de entrada/salida en pantalla :
Escribe un número real : 12.3 12.3
Ej. de entrada/salida en pantalla :
Escribe un número real : -3.25
NOTA : observar que no hemos escrito IF (EsMayor = TRUE), ya que, si bien el resultado sería el mismo, la solución utilizada es más elegante y ofrece una versión más intuitiva a todo aquel que lea el programa.
4.4. LA ESTRUCTURA IF - THEN - ELSE.
¡Error! Marcador no definido. Definicion.
La estructura IF-THEN-ELSE permite ejecutar una instrucción u otra, dependiendo de la evaluación de una expresión booleana.
A) Si la expresión booleana es cierta (TRUE), se ejecuta la instrucción1, que llamaremos instrucción THEN.
B) Si la expresión booleana es falsa (FALSE), se ejecuta la instrucción2, que llamaremos instrucción ELSE.
¡Error! Marcador no definido. Formato.
IF <expr. booleana> THEN <instrucción1> ELSE <instrucción2> ;
¡Error! Marcador no definido. Diagrama de Flujo.
Expresion Booleana
Instrucción1 True
False
Instrucción2
¡Error! Marcador no definido. Como podemos deducir del diagrama de flujo, en una estructura IF-THEN-ELSE, siempre se ejecuta alguna de las instrucciones, ya sea la instrucción THEN o la instrucción ELSE.
Ejemplo : Realizar un programa que imprima el valor de
1
n. PROGRAM EjIfThen1;VAR
N : integer;
BEGIN
write('Escribe un número entero : ');
readln(N);
IF (N mod 2=0) THEN
write('La solucion es -1');
ELSE
write('La solucion es 1');
END.
Ej. de entrada/salida en pantalla :
Escribe un número entero : 2 La solucion es 1
Ej. de entrada/salida en pantalla :
Escribe un número entero : -3 La solucion es -1
¡Error! Marcador no definido. Tanto la instrucción THEN como la instrucción ELSE pueden ser bloques BEGIN-END, por lo que tendremos las siguientes estructuras posibles :
IF <expr. booleana> THEN BEGIN
<instruccion1a>;
<instruccion1b>;
...
END
ELSE <instruccion2> ;
IF <expr. booleana> THEN <instruccion1>
ELSE BEGIN
<instruccion2a> ;
<instruccion2b> ;
...
END ;
IF <expr. booleana> THEN BEGIN
<instruccion1a>;
<instruccion1b>;
...
END
ELSE BEGIN
<instruccion2a> ;
<instruccion2b> ;
...
END ;
¡¡¡ IMPORTANTE : USO DEL PUNTO Y COMA !!!
¡ERROR! MARCADOR NO DEFINIDO. DESPUES DE TODA INSTRUCCIÓN HAY PUNTO Y COMA.
¡ERROR! MARCADOR NO DEFINIDO. ANTES DE UN ELSE NUNCA HAY PUNTO Y COMA.
¡ERROR! MARCADOR NO DEFINIDO. ANTES DE UN END, EL PUNTO Y COMA ES OPCIONAL.
Ejemplo : Realizar un programa que calcule el valor absoluto de un numero, sin utilizar la función abs( ) :
PROGRAM EjIfThenElse2;
VAR
N : integer;
BEGIN
write('Escribe un número entero : ');
readln(N);
IF (N>=0) THEN
writeln('La solucion es ', N);
ELSE
writeln('La solucion es ',-N);
END.
Ejs. de entrada/salida en pantalla :
Escribe un número entero : 2 La solucion es 2
Escribe un número entero : -3 La solucion es 3
Ejercicio propuesto : Realizar un programa que calcule las raíces de ecuaciónes de segundo grado.
y A x2 B x C Recordar que :
SI A=0 y B=0, COEFICIENTES ERRONEOS
SI A=0, B<>0 LA UNICA RAIZ ES -C/B SI A<>0, B=0, C<>0 LAS RAICES SON sqrt(-C/A) SI A<>0, B<>0, C=0 LAS RAICES SON 0 y (-B/A)
en otro caso RAICES =
B B A C A
2 4 2
NOTA : Contemplar raíces complejas.
4.5 LA ESTRUCTURA CASE.
Definicion.
La estructura CASE permite elegir la instrucción a ejecutar en función del valor de una expresion.
La expresión debe ser de tipo entero ó caracter (o incluso booleana, aunque no tiene mucho sentido), pero jamás de tipo real.
Formato.
CASE <expresión> OF
<valor1> : <instrucción1>;
<valor2> : <instrucción2>;
...
<valor-k> : <instrucciónk>;
END;
Si el valor de la expresión coincide con la constante valor1, ejecutaremos la instrucción1.
Si el valor de la expresión coincide con la constante valor2, ejecutaremos la instrucción2.
Si el valor de la expresión coincide con la constante valor-k, ejecutaremos la instrucción-k..
NOTA : valor1, valor2, ... valor-k deben ser constantes del mismo tipo que la expresión indicada. Es decir, si la expresión es entera, números enteros. Si la expresión es de tipo carácter, caracteres.
Diagrama de flujo.
Instrucción-k Instrucción2
Instrucción1
Expresion
. . .
Instrucción CASE
valor1 valor2 valor-k
Como podemos deducir del diagrama de flujo, en una estructura CASE, siempre se ejecuta alguna de las instrucciones, ya sea la correspondiente al valor1, al valor2, ... o al valor-k. Por ejemplo :
PROGRAM EjCase1;
VAR
Dia : integer;
BEGIN
write('Escribe un dia : ');
readln(Dia);
CASE Dia OF
1 : write('Lunes');
2 : write('Martes');
3 : write('Miercoles');
4 : write('Jueves');
5 : write('Viernes');
6 : write('Sabado');
7 : write('Domingo') END
END.
Tanto la instrucción1, como la instrucción2, ... como la instrucción-k pueden ser bloques BEGIN-END, por lo que la siguiente estructura CASE es también correcta :
CASE <expresión> OF
<valor1> : <instrucción1>;
<valor2> : BEGIN
<instruccion2a>;
<instrucción2b>;
<instrucción2c>;
END;
<valor3> : <instrucción3>;
...
<valor-k> : <instrucciónk>;
END;
Además, es posible que la ejecución de una instrucción se realize coincide con el valor de más de una expresión, como se ve en el ejemplo.
CASE <expresión> OF
<valor1> , <valor2>: <instruccion1>;
<valor3>, <valor4>, <valor5>:
BEGIN
<instruccion2a>;
<instrucción2b>;
END;
<valor6>: <instrucción3> ; END
EJEMPLO : Escribir un programa que solicite un mes en forma numérica (Enero=1, Febrero=2, ...), y determine cuántos días tiene dicho mes.
PROGRAM EjCase2;
VAR
Mes : integer ;
AñoBisiesto : boolean ; BEGIN
writeln('Introduce el mes (De 1 a 12)' );
readln(Mes);
CASE Mes OF :
1, 3, 5, 7, 8, 10, 12 : NumDias := 31;
4, 6, 9, 11 : NumDias := 30;
2 : BEGIN
writeln(' ¿ El año es bisiesto ?');
readln(AñoBisiesto);
IF (AñoBisiesto) THEN NumDias := 29 ELSE NumDias := 28;
END;
END;
write('El mes número ', Mes:2);
writeln(' tiene ', NumDias:2 , ' días');
END.
5. Sentencias Iterativas (Bucles)
5.1 LA ESTRUCTURA WHILE-DO.
Es la instrucción estructurada más sencilla.
Formato.
WHILE <expr. booleana> DO <instrucción> ;
Diagrama de flujo.
Expresion Booleana
Instrucción True
False
Como vemos, el orden de ejecución es el siguiente :
Paso 1 : evaluar la expresión booleana.
Paso 2 : si es TRUE, ejecutar la instrucción y volver al Paso 1.
si es FALSE, FIN.
La expresión se debe hacer FALSE en algún momento de la ejecución del bucle.
En caso contrario obtenemos lo que se llama un bucle infinito, y el programa jamás terminaría de ejecutarse.
Como siempre, la instrucción puede ser sustituída por un bloque BEGIN-END, obteniéndose :
WHILE <expr. booleana> DO BEGIN <instrucción1>;
<instrucción2>;
<instrucción3>;
...
<instrucción-k>;
END;
Ejemplo : Realizar un programa que calcule la suma siguiente : Suma = 1 + 2 + 3 ... + n
PROGRAM EjWhile1;
VAR
Indice : integer;
Suma : integer;
Numero : integer;
BEGIN
(* LECTURA DE DATOS *)
write('Escribe un número de 0 a 50 : ');
readln(Numero);
(* INICIALIZACION *) Indice := 1;
Suma := 0;
(* CALCULOS *)
WHILE (Indice<=Numero) DO BEGIN Suma := Suma + Indice;
Indice := Indice + 1;
END;
(* RESULTADO *)
writeln('La suma vale :',Suma);
END.
Ejemplos de Entrada/Salida:
Escribe un numero de 0 a 50 : 5 La suma vale : 15
Escribe un numero de 0 a 50 : 50 La suma vale : 1275
5.2 LA ESTRUCTURA REPEAT- UNTIL.
Formato.
REPEAT <instruccion> UNTIL <expr. booleana>;
Diagrama de flujo.
Expresion Booleana Instrucción
True
False
Como vemos, el orden de ejecución es el siguiente : Paso 1 : ejecutar la instrucción.
Paso 2 : evaluar la expresión booleana.
Paso 3 : si es FALSE, volver al Paso 1.
si es TRUE, FIN.
La expresión se debe hacer TRUE en algún momento de la ejecución del bucle.
En caso contrario obtenemos el bucle infinito, y el programa jamás terminaría de ejecutarse.
Como siempre, la instrucción puede ser sustituída por un bloque BEGIN-END, obteniéndose la estructura siguiente :
REPEAT BEGIN
<instrucción1>;
<instrucción2>;
<instrucción3>;
...
<instrucción-k>;
END
UNTIL <expr. booleana>;
Además se admite la siguiente estructura, similar a la anterior, pero de escritura más sencilla (será la que utilizemos) :
REPEAT
<instrucción1>;
<instrucción2>;
<instrucción3>;
...
<instrucción-k>
UNTIL <expr. booleana>;
¡¡¡ ADVERTENCIA SINTACTICA !!!
ANTES DE UN UNTIL NUNCA HAY PUNTO Y COMA
Ejemplo : Realizar un programa que calcule la suma siguiente : Suma = 1 + 2 + 3 ... + n
PROGRAM EjRepeat1;
VAR
Indice : integer;
Suma : integer;
Numero : integer;
BEGIN
(* LECTURA DE DATOS *)
write('Escribe un número de 0 a 50 : ');
readln(Numero);
(* INICIALIZACION *) Indice := 0;
Suma := 0;
(* CALCULOS *) REPEAT
Suma := Suma + Indice;
Indice := Indice + 1;
UNTIL (Indice>Numero) (* RESULTADO *)
writeln('La suma vale :',Suma);
END.
Obviamente existe una solución más sencilla, calculando la suma de una progresión aritmética :
Suma = ( (1 + N) * N ) div 2;
Cuidado, porque la solución siguiente no es correcta : Suma = ( (1 + N) div 2 ) * N;
