LENGUAJES DE PROGRAMACION

LENGUAJES DE PROGRAMACIÓN
Asignatura Clave: COM002 Número de Créditos: 9 Teórico: 4 Práctico: 5
INSTRUCCIONES PARA OPERACIÓN ACADÉMICA:
El Sumario representa un reto, los Contenidos son los ejes temáticos,
los Activos una orientación inicial para resolverlo y la síntesis concluyente,
como posibilidad de integración conceptual corresponderá a lo factible de
un punto de vista temático amplio. La visión global de los asuntos resueltos
como Titular Académico, te ofrecerá oportunidades de discusión que se
enriquecerán en la medida que intensificas las lecturas, asistes a tu comunidad
de estudio, te sirves de los asesores y analizas la ciberinformación disponible
posicionándote de los escenarios informativos adecuados. Los períodos de
evaluación son herramientas de aprendizaje. Mantén informado a tu Tutor
de tus avances académicos y estado de ánimo. Selecciona tus horarios de
asesoría. Se recomienda al Titular Académico (estudiante) que al iniciar su
actividad de dilucidación, lea cuidadosamente todo el texto guión de las
asignaturas.
COMPETENCIA: El conocimiento de las etapas necesarias para el diseño
de programas estructurados en los lenguajes de programación en general. La
utilización del entorno de programación del lenguaje Turbo Pascal en particular
para el desarrollo de sistemas de cómputo a partir de necesidades específicas
de resolución de problemas cotidianos.
SUMARIO: Percepción del por qué del desarrollo del lenguaje Turbo Pascal y
sus antecedentes. La unión de todos sus componentes para estructurarlos y
ordenarlos para la solución. Reconocer todo el proceso, dándole un
seguimiento a través de la inclusión de sus variables y constantes, para que, en
su manipulación de condiciones y ciclos, lograr la solución deseada.
LENGUAJE DE PROGRAMACIÓN
CONTENIDOS:
Unidad I
Unidad II
Unidad III
Introducción a Pascal.
Elementos básicos de turbo Pascal.
Estructura de un programa.
Unidad IV
Unidad V
Unidad VI
Unidad VII
Unidad VIII
Instrucciones de entrada / salida.
Condiciones.
Ciclos.
Funciones y procedimientos.
Archivos.
A C T I V O S
UNIDAD I
Introducción a Pascal.
I.1.- Lenguaje de programación pascal.
I.2.- Características del lenguaje pascal.
UNIDAD II
Elementos Básicos de Turbo Pascal
II.3.- Identificadores.
II.4.- Palabras reservadas.
II.5.- Tipos de datos.
UNIDAD III
Estructura de un Programa
III.8.- Cabecera.
III.9.- Declaraciones.
III.10.- Programa principal.
UNIDAD IV
Instrucciones de Entrada / Salida
IV.11.- Instrucciones de salida.
IV.12.- Instrucciones de entrada.
UNIDAD V
Condiciones
V. 13.- IF…THEN ó IF…THEN…ELSE.
V. 14.- IF anidadas.
V. 15.- CASE…OF.
UNIDAD VI
Ciclos
VI.16.VI.17.VI.18.VI.19.-
FOR.
WHILE.
REPEAT-UNTIL.
Ciclos anidados.
UNIDAD VII
Funciones y Procedimientos
VII.20.- Procedimientos.
VII.21.- Funciones.
UNIDAD VIII
Archivos
VIII.22.- Archivos directos.
Actividad 1: Ejercicios de práctica.
Actividad 2: Elaboración de proyecto.
ESCENARIOS INFORMATIVOS:
•
•
•
Disposición en Internet.
Curso de Pascal: http://members.es.tripod.de/ncabanes/cupas0.htm
Tutorial de Turbo Pascal: http://members.xoom.com/tutoriales/
•
•
•
•
Aprendizaje de Pascal: http://www.algonet.se/~khaan/tutor/index.html
http://www.borland.com/pascal/pascalnet.html
Puntualidad en Intranet.
Fuentes Directas e Indirectas.
BIBLIOGRAFÍA:
Joyanes Aguilar, Luis.
1992
Programación en Turbo Pascal.
Editorial Mc Graw Hill, México, 822 pp.
1992
0’brien, Stephen.
Turbo Pascal 6, Manual de Referencia.
Editorial Mc Graw Hill, México, 667 pp.
LENGUAJE DE PROGRAMACIÓN
PRINCIPIA TEMÁTICA:
I.1.- LENGUAJE DE PROGRAMACIÓN PASCAL.
El lenguaje de programación PASCAL es un lenguaje de alto nivel y propósito
general, es decir, es usado para un grán número de aplicaciones diversas. Fue
desarrollado por el Profesor Suizo Niklaus Wirth para enseñar la programación
de modo disciplinado y sistemático.
Una versión preliminar de este lenguaje apareció en 1968, y el primer
compilador totalmente completo apareció a finales de 1970, (en 1971, según
algunos historiadores informáticos) desde entonces muchos compiladores hán
sido construidos.
I.2.- CARACTERÍSTICAS DEL LENGUAJE PASCAL.
El lenguaje pascal estándar presenta una serie de características que los
hacen idóneo como primero o segundo lenguaje de programación, desde el
punto de vista del aprendizaje y como lenguaje de propósito general para la
resolución de aplicaciones de todo tipo: de gestión, científicas, de ingeniería,
etc.
A continuación se destacan las características más sobresalientes del lenguaje
Pascal:
Lenguaje excelente para aprendizaje de programación.
Lenguaje de propósito general.
Lenguaje procedural (imperativo, orientado a órdenes).
Lenguaje estructurado (soporta las estructuras básicas while, for y repeat).
Lenguaje recursivo (soporta recursividad, que es la propiedad de llamarse a sí
mismo, una función o procedimiento).
Gran riqueza de tipos, con tipos de datos simples y estructurados, así como
datos definidos por el usuario.
Producción por los compiladores de programas ejecutables rápidos y eficientes.
Facilidad para realizar la programación modular, debido a la posibilidad de
diseñar subprogramas o módulos del tipo procedimiento y función.
En 1983, la firma Borland International lanzó con gran éxito al mercado un
compilador de Pascal llamado Turbo Pascal (versión 1.0), cuya razón
fundamental de su éxito no solo residió en su bajo costo, sino que ofrecía al
mismo tiempo un entorno de programación (editor/compilador) y numerosas
utilidades inexistentes en las versiones anteriores de Pascal tales como
gráficos, colores, gestionador de archivo, etc.
Posteriormente, Borland lanzó nuevas versiones con mejoras significativas. En
1989, sacó Turbo Pascal versión 5.5 que sigue las nuevas filosofías de la
programación: programación orientada a objetos, que es a decir de los
expertos la programación del futuro.
Turbo Pascal es sin lugar a dudas una herramienta de programación potente,
fácil de utilizar e idónea para el aprendizaje de profesionales y aficionados a la
programación.
II.3.- IDENTIFICADORES.
Los identificadores son palabras que representan constantes, variables, tipos
de datos, procedimientos, funciones y algunos otros datos. Existen dos tipos de
identificadores: los predefinidos de Turbo Pascal y los definidos por el
programador.
Algunos de los identificadores predefinidos son: integer, real, byte, sin, etc.
Los identificadores definidos por el programador son los elementos del lenguaje
tales como variables, procedimientos, funciones, etc.
Un identificador es una secuencia de 1 a 127 caracteres, que inicia con una
letra, no tienen espacios ni símbolos: &, !, *, etc., y no es alguna palabra
reservada.
Para Turbo Pascal no existen diferencias entre mayúsculas y minúsculas, así
que a un identificador denominado "valor", se le puede referir como "VALOR" o
"Valor".
Todo identificador en Pascal debe ser definido previamente a su utilización.
II.4.- PALABRAS RESERVADAS.
Para poder programar en cualquier lenguaje, es necesario conocer los códigos
mediante los cuales podamos expresar las tareas que queremos realizar. Turbo
Pascal, como lenguaje de programación, posee su propio código con palabras
de uso exclusivo para ciertas funciones, a estas palabras les llamaremos
palabras reservadas de Turbo Pascal.
Las palabras reservadas de Turbo Pascal (versiones 6.0 o mayores) son:
Pascal Estándar y Turbo Pascal 6.0
AND
ARRAY
BEGIN
CASE
CONST
DIV
DO
DOWNTO
ELSE
END
FILE
FOR
FORWARD
FUNCTION
GOTO
IF
IN
LABEL
MOD
NIL
NOT
OF
OR
PACKED
PROCEDURE
PROGRAM
RECORD
REPEAT
SET
THEN
TO
TYPE
UNTIL
VAR
WHILE
WITH
Turbo Pascal
ABSOLUTE
IMPLEMENTATION
PRIVATE
VIRTUAL
INLINE
STRING
ASM
INTERFACE
SHR
CONSTRUCTOR
INTERRUPT
USES
DESTRUCTOR
OBJECT
UNIT
EXTERNAL
SHL
XOR
Estas palabras no pueden ser usadas como identificadores (siguiente
tópico), ya que cada una de ellas tiene una función definida en Turbo
Pascal.
II.5.- TIPOS DE DATOS
El manejo de la información en Turbo Pascal se realiza mediante
diferentes
clases de datos. En este apartado se tratarán los principales tipos:
Integer
Char
Bolean
Real
String
Números enteros sin parte decimal.
Caracteres del código ASCII
Pueden contener los valores de falso o verdadero
Números que pueden incluir una parte decimal
En una secuencia de caracteres que se trata como un solo dato.
Un programa debe ser capaz de manejar diferentes tipos de datos, como
pueden ser: números enteros, reales, caracteres, cadenas de
caracteres, etc. Para lograr el manejo de toda esta información, Turbo Pascal
provee
diferentes tipos de datos para los identificadores que se utilizarán.
Algunos
de los más importantes se citan enseguida:
Enteros.- En esta categoría Turbo Pascal cuenta con 5 tipos diferentes,
cada uno abarca un rango específico de valores y utilizan una diferente
cantidad de memoria dependiendo de ese rango. Naturalmente el
trabajar
espacio en
precisión.
con rangos menores nos ofrece una mayor velocidad y menor
memoria, pero si se utilizan enteros largos se cuenta con mayor
Los tipos de enteros en Turbo Pascal son:
Tipo
Integer
Word
ShortInt
Byte
LongInt
Rango de valores que acepta
-32,768 a 32,767
0 a 65535
-128 a 127
0 a 255
-2,147,483,648 a 2,147,483,648
Al utilizar los tipos enteros es posible representar en el programa un
número
en formato hexadecimal, para hacer esto solo se le antepone el
símbolo "$" al valor hexadecimal, al momento de visualizar dicho valor, o
utilizarlo en alguna operación será como decimal. Por ejemplo:
Cantidad:= $10;
El valor que se guarda en "Cantidad" es 16.
Reales.- Los números reales son aquellos que cuentan con una parte decimal.
En
Turbo Pascal contamos con varios tipos de datos reales, pero no se
pueden
utilizar, más que el tipo real, en máquinas que no cuenten con un
coprocesador matemático. Los tipos de datos reales son:
Tipo
Real
Single
Double
Extended
Comp
Rango de valores que acepta
2.9E-39 a 1.7E38
1.5E-45 a 3.4E38
5.0E-324 a 1.7E308
1.9E-4851 a 1.1E4932
-9.2E18 a 9.2E18
Los números reales deben llevar por fuerza al menos un dígito de cada
lado del punto decimal así sea éste un cero. Como ejemplo, el número 5 debe
representarse como 5.0, el .5 como 0.5, etc.
En este tipo de datos se utiliza la notación científica, que es igual a la de
las
calculadoras, el dígito que se encuentra a continuación de la E
representa la potencia a la que se elevará el número 10 para multiplicarlo por
la
cantidad a la izquierda de dicha E:
3.0E5 = 3.0 * 10^5 = 3.0 * 100000 = 300000
1.5E-4 = 1.5 * 10^-4 = 1.5 * 0.0001 = 0.00015
Caracter.Los caracteres son cada uno de los símbolos que forman el código
ASCII,
el tipo estándar de Pascal para estos datos es Char. Los
caracteres se
especifican entre apóstrofes:
’a’</TD
'B'</TD
'2' '#'
El tipo Char es un tipo ordinal de Pascal, esto quiere decir que sus
elementos válidos siguen una secuencia ordenada de valores
individuales. La secuencia de caracteres para este tipo corresponden al
número del código ASCII, del 0 al 255.
Es posible accesar a cada uno de los caracteres utilizando un signo #
antes de su valor correspondiente, por ejemplo, la letra A puede ser
representada
como #65, el retorno de carro, o enter, se representa como
#13, y así
cualquier carácter.
Cadena
de
Las cadenas son secuencias de caracteres o arreglos que tienen una
longitud máxima de 255 caracteres. Se definen entre apóstrofes. El tipo
Pascal para las cadenas es String.
PROGRAM Cadena;
VAR
Nombre: String;
BEGIN
Nombre:= 'Ernesto Chávez';
Writeln (Nombre);
END.
III.8.- CABECERA.
que
El lenguaje utilizado en Turbo Pascal es estructurado, lo que significa
cada programa requiere una forma específica de escritura para que sea
entendido por el compilador.
Todo programa cuenta con algunas partes o módulos los cuales son:
Cabecera
Declaraciones
Programa
La cabecera del programa únicamente lleva el nombre del programa. En
la
sección de declaraciones se le indica al compilador todos los
identificadores
y unidades que se utilizarán durante la ejecución del
programa. En la
sección del programa se escribe el código de instrucciones
que se llevarán
a cabo.
Cabecera
PROGRAM Nombre del programa;
USES Nombre de unidad1, Nombre de unidad2, .., Nombre de
unidadN;
LABEL Declaraciones de etiquetas;
Declaraciones
CONST Declaraciones de constantes;
TYPE Declaraciones de tipos definidos por el usuario;
VAR Declaraciones de variables;
PROCEDURE, FUNCTION Declaraciones de procedimientos y
funciones;
BEGIN Programa principal
........
Cuerpo
Sentencias del programa principal
........
END.
CABECERA.
Sentencia PROGRAM
La sentencia PROGRAM es la declaración del nombre del programa.
Consta de tres partes: la palabra reservada PROGRAM, a continuación
un
identificador utilizado como el nombre del programa y al final un punto y
coma ";". Por ejemplo:
PROGRAM suma_de_dos_números ;
Esta declaración es siempre la primer línea en cualquier programa de
Turbo Pascal.
III.9 DECLARACIONES.
Declaración de unidades
Las unidades son módulos independientes del programa que, aunque no
son ejecutables por si mismos, pueden ser utilizados por el programa
principal sin necesidad de reescribir el código que contienen. Para la
utilización de estos "subprogramas" es necesaria su declaración.
La palabra reservada USES cumple el propósito de declarar las
unidades
en el formato siguiente:
USES crt, dos;
Esta línea declara y habilita para su uso a la unidad crt y a la unidad
dos Cada unidad que se declara deberá estar separada de la siguiente por
una coma. Al final de todas las unidades declaradas se deberá colocar un
punto y coma ";". Declaración de constantes y variables para declarar las
constantes se utiliza la palabra reservada CONST seguida de un
identificador al que se le dará un valor determinado, un signo de igual
"=", el valor que recibirá el identificador y al final un punto y coma ";". Ejemplo:
CONST pi = 3.1415926;
De esta forma el identificador pi recibirá el valor de 3.1415926 y no será
posible cambiarlo en el transcurso del programa. Es posible declarar
varias constantes sucesivamente, puede ser una por renglón o varias en un
solo
renglón. Cuando se hace esto, la palabra CONST solo se pone una sola
vez como cabecera y a continuación todas las constantes por definir.
Ejemplo:
CONST
PI = 3.1415926;
Nombre = 'Juan Gutiérrez';
Unidad = 1;
Otra forma de escribir lo mismo es así:
CONST PI = 3.1415926; Nombre = 'Juan Gutiérrez'; Unidad = 1;
en
Pero por cuestiones de legibilidad es preferible la primera opción.
La declaración de variables se lleva a cabo de la misma forma, solo que
lugar de la palabra CONS utilizamos la palabra VAR, y en lugar de "=
valor;", utilizamos : Tipo, sustituyendo "tipo" por alguna clase válida de
datos en Turbo Pascal. Ejemplo:
VAR Num_entero : Integer;
Nombre : String;
III.10 SECCION EJECUTABLE O PROGRAMA PRINCIPAL
se
con
se
o
Programa principal después de haber realizado todas las declaraciones
puede iniciar con el programa principal. (Es posible, antes del programa,
declarar las funciones y procedimientos, pero eso se analizará
posteriormente).
El programa principal inicia con la palabra reservada BEGIN y termina
la palabra END., esta última con un punto al final.
Cada línea de código, enunciado, sentencia o instrucción completa que
escriba deberá terminar con un punto y coma ";".
Solo se omitirá el punto y coma cuando se utiliza la palabra reservada
ELSE. Aunque puede también omitirse si la siguiente expresión es END
UNTIL.
Ya conociendo la estructura es posible escribir un primer programa:
PROGRAM Primera_Prueba;
VAR
Entero: Integer;
CONST
Mensaje = 'Introduce un valor entero: ';
Respuesta = 'El valor es: ';
BEGIN
Write(Mensaje);
{Escribe en pantalla el mensaje definido como constante}
ReadLn(Entero);
{Lee un valor de teclado y lo almacena en la variable Entero}
WriteLn(Respuesta, Entero);
{Escribe en pantalla el contenido de Respuesta y el valor que se ingresó de
teclado}
END.
las
Como podrá apreciarse, no es importante el orden en el que se declaran
variables y constantes (aplicable solo al Turbo Pascal), es decir, pueden
declararse primero las variables y luego las constantes y viceversa:
PROGRAM Primera_Prueba;
CONST
Mensaje = 'Introduce un valor entero: ';
Respuesta = 'El valor es: ';
VAR
Entero : Integer;
BEGIN
Write(Mensaje);
{Escribe en pantalla el mensaje definido
como constante}
ReadLn(Entero);
{Lee un valor de teclado y lo almacena en
la variable Entero}
WriteLn(Respuesta, Entero);
{Escribe en pantalla el contenido de
Respuesta y el valor que se ingresó de
teclado}
END.
IV.11 INSTRUCIONES DE SALIDA.
los
Salida de datos a la pantalla
Las instrucciones que permiten mostrar datos en la pantalla de la
computadora son: Write y WriteLn. Aunque ya se hizo uso de ellas en
pequeños programas anteriores de ejemplo, aquí se describirán a fondo.
La sintaxis de los procedimientos es la siguiente:
Write (indentificadores);
WriteLn (indentificadores);
Donde los identificadores son aquellos que contienen la
información que se desea mandar a la pantalla. Es posible
utilizar
varios de ellos por cada instrucción Write o WriteLn,
únicamente
se separan unos de otros por comas ",". Ejemplo:
Write (Nombre, ApellidoP, ApellidoM);
Esta línea de código desplegará consecutivamente los contenidos de los
identificadores Nombre, ApellidoP y ApellidoM. En caso de que la
variable
Nombre almacenara el valor 'Rodrigo ', la variable ApellidoP
'González ' y la
variable ApellidoM 'García', el resultado en pantalla sería:
Rodrigo González García
Podemos obtener el mismo resultado si utilizamos la siguiente
estructura:
Write (Nombre);
Write
(ApellidoP);
Write
(ApellidoM);
la
Si en lugar de utilizar la instrucción Write hacemos uso de WriteLn con
misma sintaxis del ejemplo anterior:
WriteLn (Nombre);
WriteLn (ApellidoP);
WriteLn (ApellidoM);
lo que obtendríamos sería:
Rodrigo
González
García
De este ejemplo es posible concluir que la diferencia entre las
instrucciones
Write y WriteLn es que esta última imprime el contenido de
los
identificadores y cambia el cursor al siguiente renglón de la pantalla, y la
primera solo escribe el contenido y deja el cursor al final del dato escrito.
IV.12 INSTRUCCIONES DE ENTRADA.
Entrada de datos desde teclado
Las instrucciones estándar de Turbo Pascal para obtener datos desde el
teclado son Read y ReadLn. La sintaxis de estas instrucciones es muy
parecida a la de Write y WriteLn:
Read (Identificador);
El identificador puede ser cualquier variable definida previamente, NO
puede ser una constante. Puede ser también un conjunto de variables,
separadas entre comas, en este caso se guardara el primer valor dado
antes del [Enter] en el primer identificador proporcionado, luego el
segundo y así sucesivamente hasta el último identificador.
La diferencia en el uso de la instrucción Read con respecto a ReadLn es
que en la primera, si se le dan mas datos de los que se introducirán se
guardan en un buffer y se usarán en la siguiente instrucción Read o
ReadLn del programa, en cambio ReadLn ignora todo dato posterior a
los que estén definidos en la instrucción.
En caso de que se le indique a Read o ReadLn que lea un tipo
específico de valor, y se le proporcione otro diferente se generará un
error y se detendrá la ejecución del programa.
Asignaciones
La asignación nos permite situar un valor que es el resultado de la
evaluación de una expresión. El símbolo utilizado para la asignación
es:= (dos puntos igual) y el formato es el siguiente:
variable := expresión;
donde variable es el identificador que ha sido declarado en la sección de
declaración de variables, expresión puede ser una constante o variable
simple, o bien una combinación de constantes, variables y operadores
aritméticos.
Un ejemplo sería:
Nombre:='Fernando A. Hinojosa L.';
Suma := 10 + 30;
Total := Suma * (n-1);
Contador := Contador + 1;
V.13 IF…THEN
ó IF…THEN…ELSE
Para crear un buen programa es necesario dotarlo con capacidad de
decisión con base en las variables o eventos definidos por el
programador,
para que el programa sea aplicable en un entorno más
generalizado y no solo para un problema específico.
Para lograr este control se cuenta con las estructuras de control que, en
Turbo Pascal, son las siguientes:
Sentencia sencilla IF...THEN y sentencia doble IF...THEN...ELSE
Sentencia sencilla:
La forma más sencilla de bifurcación condicional es la sentencia IF...THEN,
que hace que un programa ejecute un bloque de código si es cierta una
condición
Sentencia doble IF...THEN...ELSE
Expresión
¿cierto o falso?
cierto
Ejecutar sentencia
Continuar con el
programa
falso
Esta expresión es utilizada para ejecutar una sentencia en el caso que una
condición establecida sea verdadera, de lo contrario se podrá ejecutar una
sentencia distinta. Su sintaxis es:
IF condición THEN instrucción ELSE otro
Donde condición es la expresión que se evaluará, en caso de ser verdadera se
ejecutará la sentencia dada como instrucción, en caso de que la condición sea
falsa se ejecutara la sentencia dada como otro. Ejemplo:
Expresión booleana
FALSO
CIERTO
¿cierto o falso?
Ejecutar
sentencia
Ejecutar
sentencia
del
del
IF...THEN
ELSE
Continuar con
el programa
PROGRAM IF_THEN_ELSE;
VAR
Contador: Integer;
BEGIN
FOR contador: = 1 to 50 DO
BEGIN
IF contador > 10 THEN WriteLn(Contador) ELSE WriteLn('*');
END;
END.
En este pequeño programa la variable Contador se incrementará desde
1
hasta 50, la sentencia condicional IF verificará si es verdad que
Contador es mayor a 10, de ser así se escribirá en pantalla el valor de la
variable, de lo
contrario se escribirá en la pantalla un carácter "*". Como el
contador inicia
desde 1, tenemos que se imprimirán 10 asteriscos antes
del primer número, que será el 11, valor que si cumple la condición "Contador
> 10" (la hace
verdadera).
La sección ELSE con su correspondiente sentencia son opcionales y
pueden omitirse en caso de no necesitarse.
V.14 IF…ANIDADAS
Es posible utilizar en una expresión del tipo IF..THEN..ELSE una
sentencia
compuesta como la sentencia a ejecutarse en caso de que la
condición sea
verdadera, así como en la sentencia posterior a un ELSE,
de esta forma
podemos utilizar otra sentencia IF..THEN..ELSE dentro de
la anterior, para
de esta forma evaluar varias condiciones una dentro de
otra. Ejemplo:
IF Número > 5 THEN
BEGIN
IF Número < 10 THEN Opción := Número;
IF Número < 30 THEN Opcion2 := Número;
END;
V.15 CASE…OF
Esta forma de control se utiliza cuando se va a evaluar una expresión
que puede contener varios datos diferentes y en cada dato deberá realizar
una acción especial. Por ejemplo, si se crea un menú con diferentes
opciones
se realizará un determinado proceso para cada acción, aunque la
selección
por parte del usuario se haga desde el mismo lugar.
El siguiente programa ilustra el uso de la forma CASE, el programa
preguntará un número al usuario y lo clasificará de acuerdo a su valor.
PROGRAM Case;
VAR
Numero: Integer;
BEGIN
WriteLn('Introduzca un número entero del 1 al 5: ');
ReadLn(Numero);
CASE Numero OF
1 : WriteLn('El número fue 1');
2 : WriteLn('El número fue 2');
3 : WriteLn('El número fue 3');
4 : WriteLn('El número fue 4');
5 : WriteLn('El número fue 5');
ELSE WriteLn('El número no estaba en el rango indicado');
END.
VI.16 FOR
El ciclo FOR repite una sentencia un determinado número de veces que
se indica al momento de llamar al ciclo.
Lo que hace FOR es que incrementa una variable en uno desde un valor
inicial hasta un valor final ejecutando en cada incremento la sentencia
que se quiere repetir. Su sintaxis es:
FOR identificador := inicio TO fin DO instrucción;
Donde el identificador es la variable que se incrementará, inicio es el
primer valor que tendrá dicha variable y fin es el valor hasta el cual se
incrementará la misma; instrucción es la sentencia (sencilla o
compuesta) que se ejecutará en cada incremento de la variable.
El siguiente ejemplo escribe los números del 1 al 50 en pantalla. La
variable utilizada es "Numero".
PROGRAM Ciclo_FOR;
VAR
Numero : Integer;
BEGIN
FOR Numero := 1 to 50 DO
WriteLn(Numero);
END.
Una de las limitaciones de los ciclos FOR es que una vez iniciado el ciclo
se ejecutará el número de veces predefinido sin posibilidad de agregar o
eliminar ciclos.
Es posible hacer que un ciclo cuente hacia atrás, es decir que la variable
en lugar de incrementarse se decremente. Para ésto cambiamos la
palabra TO por DOWNTO, y colocamos el valor mayor a la izquierda y el
menor a la derecha. Ejemplo:
PROGRAM Ciclo_FOR_2;
VAR
Número: Integer;
BEGIN
FOR Número := 50 DOWNTO 1 DO
WriteLn (Número);
END.
VI.17 WHILE
Los ciclos WHILE ofrecen la ventaja de que la ejecución se realiza
mientras se cumpla una condición, por lo tanto es posible controlar el
número de repeticiones una vez iniciado el ciclo. Su sintaxis es:
WHILE condición DO instrucción
Donde condición es la condición que se evaluará, mientras ésta sea
verdadera se ejecutará la instrucción, que es una sentencia simple o
compuesta.
Un programa que escriba los números del 1 al 50, utilizando el ciclo
WHILE se vería como sigue:
PROGRAM Ciclo_WHILE;
VAR
Número: Integer;
BEGIN
Número := 1;
WHILE Número <= 50 DO
BEGIN
WriteLn (Número);
Número := Número +1;
END;
END.
Al final del programa la variable Número guardará el valor 51, que fue el valor
que no cumplió con la condición establecida en el ciclo WHILE.
VI.18 REPEAT UNTIL
Este tipo de ciclos es muy parecido a los ciclos WHILE, la diferencia
entre ambos es que en WHILE la condición se evalúa al principio del ciclo, en
cambio en REPEAT-UNTIL se evalúa al final, lo que significa que en un
ciclo REPEAT-UNTIL la sentencia se ejecutará por lo menos una vez,
cosa que puede no ocurrir en el ciclo WHILE. Ejemplo:
PROGRAM Ciclo_RepeatUntil;
VAR
Número : Integer;
BEGIN
Número := 1;
REPEAT
WriteLn (Número);
Número := Número + 1;
UNTIL Número = 50;
END.
VI.19 CICLOS ANIDADOS
Puede constar de un número ilimitado de sentencias de cualquier ciclo.
Observándose que cada ciclo debe iniciarse y cerrarse sin llegar a
cruzar
ningún otro ciclo:
PROGRAM CASCADA;
USES CRT;
VAR
NOMBRE:STRING[30];
X,J,Y,I:INTEGER;
BEGIN
TEXTBACKGROUND(BROWN);
CLRSCR;
GOTOXY(7,9);WRITE('DAME EL TEXTO:');
READLN(NOMBRE);
FOR I:=1 TO LENGTH(NOMBRE) DO
BEGIN
GOTOXY(20+I,9);WRITE(' ');
FOR Y:= 10 TO 18 DO
BEGIN
GOTOXY(20+I+Y-9,Y); WRITE(NOMBRE[I]);
DELAY(4000);
GOTOXY(20+I+Y-9,Y); WRITE(' ');
END;
GOTOXY(20+I+Y-9,19);WRITE(NOMBRE[I]);
END;
DELAY(15000);
END.
VII.20 PROCEDIMIENTOS
Definición de procedimiento
Un procedimiento es un grupo de sentencias que realizan una tarea concreta.
En lugar de reescribir el código completo de esa tarea cada vez que se
necesite, únicamente se hace una referencia al procedimiento.
Por ejemplo, es muy común que se quiera visualizar un título determinado
varias veces en un programa, para evitar teclear ese título en nuestro programa
fuente todas las veces que sea necesario creamos un procedimiento llamado
"Titulo" que se encargará de escribirlo.
Una vez creado un procedimiento actuará como una instrucción más de Turbo
Pascal, y para ejecutarlo únicamente teclearemos el nombre de dicho
procedimiento.
Para poder ejecutar un procedimiento es necesario declararlo en el programa
que se este utilizando.
Creación de los procedimientos
El primer paso para crear un procedimiento es saber que queremos que haga.
Una vez definiendo este punto declaramos el procedimiento después de haber
declarado variables y constantes, antes del cuerpo del programa principal. La
palabra reservada para su declaración es Procedure seguida del nombre del
procedimiento. Vamos a crear un procedimiento encargado de escribir en
pantalla el enunciado "Programa de Turbo Pascal":
PROCEDURE Titulo;
BEGIN
WriteLn ('Programa de Turbo Pascal');
END;
Uso de los procedimientos
Una vez declarado el procedimiento es posible utilizarlo como una instrucción
de Turbo Pascal. Al uso de un procedimiento se le conoce como llamada al
procedimiento.
El siguiente programa ilustra el uso o la llamada al procedimiento creado
anteriormente:
PROGRAM Procedimientos;
PROCEDURE Titulo;
BEGIN
WriteLn ('Programa de Turbo Pascal');
END;
BEGIN
WriteLn ('Programa ejemplo del uso de procedimientos');
Titulo;
{Llama al procedimiento}
WriteLn;
Titulo;
{Vuelve a llamar al procedimiento}
END;
VIII.22 ARCHIVOS DIRECTOS
Un archivo contiene una secuencia de componentes accesibles
individualmente todos pertenecientes al mismo tipo de datos. Puesto que
las posiciones de los registros individuales son directamente accesibles
se usa el término de acceso aleatorio para describir el uso de dichos
archivos.
Un archivo puede por sí mismo ser una variable, en la declaración
se usa las palabras reservada FILE OF en el siguiente formato:
Var
TYPE FILE VAR : FILE OF ComponentType.
El commando Seek es la llave para accesar el archivo en un registro
particular. El programa puede cargar el registro en memoria ó escribirlo
en cierta posición.
Assign es un procedimiento que establece una asociación entre
variable de archivo y el nombre del archivo en disco.
Reset abre un nuevo archivo ó un existente en disco cuando no
se asocia con el procedimiento Rewrite para generarlo.
la
existe
Las operaciones de lectura de cierto registro o de escritura se hacen con
las típicas instrucciones Read, Write.
Ya que se han efectuado las operaciones del archivo se debe cerrar con
Close.
File Size regresa el número de registros almacenados en el archivo.
{ I - } { I + } directivas de compilador para validar errores en la
apertura
de archivos
el
I – O RESULT función que regresa un valor 0 cuando se abre con éxito
archivo, de lo contrario la variable a la que se asigna toma un valor
negativo.
Program empleados;
uses Crt;
Type
Datos=record
cve:byte;
nom:string [30];
pago:longint;
end;
Var
Empleado:File of Datos;
em:Datos;
Op, I:Byte;
Len:Integer;
Procedure Abrir;
var
A:Byte;
Begin
Assign(Empleado,'A:empleado.dat');
{$ I-}
Reset(empleado);
{$ I+}
A:=IORESULT;
If A<> 0 then
Begin
Writeln('Archivo no existe');
Rewrite (empleado);
End;
End;
Actividad 1: Ejercicios de Práctica.
EJERCICIOS
Que deberán entregarse impresos y en diskette
1.- Un año es bisiesto si es divisible por 4, pero no por 100. Una
excepción son los años divisibles por 400, que son todos bisiestos.
Escriban un programa que lea un año, suministrado por teclado, y
determine y escriba si ese año es o no bisiesto.
PROGRAM BISIESTO;
uses crt,dos;
var
A:integer;
op:char;
Begin
Clrscr;
Textcolor(27);
Repeat
Gotoxy(20,5);
WriteLn('Programa para conocer si un año es bisiesto');
Until KeyPressed;
Textcolor(10);
Repeat
Clrscr;
Write('dame un Año: ');readln(A);
If ((A mod 4=0) And (A mod 100<>0) Or (A mod 400=0)) Then
Write(A, ' es un año bisiesto')
else
Write(A, ' No es un año bisiesto');
WriteLn;
Writeln('Deseas conocer otro Año Si/No ...');Readln(op);op:=Upcase(op);
Until op='N';
End.
2.- La serie Fibonacci: 1,1,2,3,,5,8,13,21,…
Se define suponiendo que los dos primeros términos tienen el valor de 1
y
que cada término subsiguiente está dado por la suma de los términos
procedentes:
1+1=2
1+2=3
2+3=5
3+5=8
Etcétera.
Diseñe el programa en Pascal.
3.- Elabore un programa en Pascal que nos diga si el número que le
damos
es número primo. Los números primos son enteros mayores que
1 sin divisores enteros positivos, excepto el 1 y ellos mismos. Una
observación interesante es que todos los números primos son impares excepto
el 2. Otra
observación es que sólo necesitamos comprobar la divisibilidad
por números superiores a la raíz cuadrada del número.
4.- Escribir un programa para calcular las comisiones sobre ventas de un
agente de el cual basa sus comisiones en:
Si la venta es menor a 1,000 000 obtiene el 5%
Si la venta > = 1,000 000 y < = 3,000 000 obtiene el 8%
Si la venta es mayor 3,000 000 obtiene el 10%
5.- Ejecutar el siguiente programa y hacer las modificaciones pertinentes. Aquí
se usan los comandos para la escritura de archivos de datos.
Program emplea;
uses crt;
Type
Datos=Record
cve:Byte;
nom:String[30];
pago:LongInt;
end;
Var
Empleado:File of Datos;
em:Datos;
op,I:Byte;
Len:Integer;
{***************}
Procedure Abrir;
Var
A:Byte;
Begin
Assign(Empleado,'C:empleado.Dat');
{$I-}
Reset(Empleado);
{$I+}
A:=IOResult;
If A<>0 Then
begin
WriteLn('Archivo no Existe');
ReWrite(Empleado);
end;
End;
{***************}
Procedure Cerrar;
Begin
Close(empleado);
End;
{***************}
Procedure Altas;
Var
cla:Byte;
B: Boolean;
Begin
Repeat
ClrScr;
GotoXY(7,2);WriteLn('*** Altas al Archivo de empleados');
GotoXY(7,12);WriteLn(' Para salir la clave es 0');
Len:=Filesize(empleado);
GotoXY(10,4);Write('Clave:');Readln(Cla);
If Cla<>0 Then
begin
B:=False;
For I:=1 To Len Do
begin
Seek(empleado,I-1);
Read(empleado, em);
If em.cve=cla Then
begin
GotoXY(10,5);WriteLn('Nombre: ',em.nom);
GotoXY(10,6);WriteLn('Pago: ',em.pago);
GotoXY(10,8);WriteLn('Registro ya existe');
Delay(50000);
B:=True;
I:=Len;
end;
end;
If Not B then
begin
With em Do
begin
GotoXY(10,5);Write('Nombre');Readln(nom);
GotoXY(10,6);Write('Pago');Readln(pago);
cve:=cla;
end;
Write(empleado,em);
end;
end;
Until cla=0;
End;
{***************}
Procedure Bajas;
var
cla:Byte;
B:Boolean;
Begin
Repeat
ClrScr;
GotoXY(7,2);Write('Bajas');
Len:=FileSize(empleado);
GotoXY(10,4);Write('Clave');Readln(cla);
If cla<>0 Then
begin
B:=False;
For I:=1 To Len Do
begin
Seek(empleado, I-1);
Read(empleado, em);
If em.cve=cla Then
begin
GotoXY(10,5);Write('Nombre',em.nom);
GotoXY(10,6);Write('Pago',em.pago);
GotoXY(10,8);Write('Registro no existe');
Delay(500);
B:=True;
I:=Len;
em.cve:=0;
em.nom:='';
em.pago:=0;
Seek(empleado, I-1);
Write(empleado,em);
end;
end;
If Not B Then
begin
GotoXY(15,8);WriteLn('Registro No Existe');
Delay(3000);
end;
end;
If Not B Then
begin
GotoXY(15,8);Write('Registro No existe');
Delay(3000);
end;
Until cla=0;
End;
{***************}
Procedure Consultas;
begin
Clrscr;
GotoXY(18,15);Write('falta de tu parte terminar este procedimiento');
Readln;
end;
{***************}
Procedure Reportes;
begin
Clrscr;
GotoXY(18,15);Write('Aqui es la seccion de mandar a imprimir, opcional');
Readln;
end;
{***************}
Begin
Textcolor(7);
TextBackGround(9);
ClrScr;
Window(10,5,70,19);
TextBackground(3);
ClrScr;
Window(15,6,65,17);
Textbackground(5);
Abrir;
Repeat
ClrScr;
GotoXY(14,2);Write('MENU DE OPCIONES');
GotoXY(18,4);Write('1] ALTAS');
GotoXY(18,5);Write('2] BAJAS');
GotoXY(18,6);Write('3] CONSULTAS');
GotoXY(18,7);Write('4] REPORTES');
GotoXY(18,8);Write('5] SALIR');
GotoXY(18,9);Write('OPCION [ ] ');
GotoXY(27,9);Readln(op);
Case op Of
1:ALTAS;
2:BAJAS;
3:CONSULTAS;
4:REPORTES;
5:CERRAR;
Else
begin
Writeln('OPCION NO VALIDA');
Delay(3000);
end;
End;
Until op=5
End.
6.- Ejecutar el siguiente programa que está basado en el modo gráfico de
Pascal.
{en Pascal podemos programar en modo Texto y modo gráfico
En el curso anterior vimos únicamente el modo texto.
Este programa ilustra el modo gráfico, donde se utilizan algunos comandos
para dibujar figuras, se recomienda ejecutar este programa para su
visualización, aclarándose que no es sujeto de evaluación el tema de modo
gráfico}
program dibujo; {En este programa se utiliza el modo Grafico}
uses crt,graph; { Uso de la Unidad GRAPH }
var
CODIGOERROR, MODOGRAF, MODO, DRVGRAF,x,y: INTEGER;
(***********************************************)
Procedure A;
Begin
x:=0;y:=0;
For x:=425 Downto 50 Do
begin
linea(x,50,x-10,50); {trazar linea}
Delay(200);
end;
End;
(**************************************************)
Procedure B;
Begin
x:=0;y:=0;
ARC(45,75,90,180,25);
{trazar un arco}
End;
(**************************************************)
Procedure C;
Begin
x:=0;y:=0;
For y:=75 to 400 Do
begin
line(20,y,20,y+10);
Delay(150);
end;
End;
(**************************************************)
Procedure D;
Begin
x:=0;y:=0;
ARC(45,410,180,270,25);
End;
(**************************************************)
Procedure E;
Begin
x:=0;y:=0;
For x:=55 to 450 Do
begin
line(x,435,x-10,435);
Delay(100);
end;
End;
(**************************************************)
Procedure F;
Begin
x:=0;y:=0;
ARC(446,399,270,120,35);
End;
(**************************************************)
Procedure G;
Begin
x:=0;y:=0;
SetColor(11);
SetLineStyle(1,1,1);
For x:=430 Downto 300 Do
begin
line(x,370,x-10,370);
Delay(5);
end;
End;
(**************************************************)
Procedure H;
Begin
x:=0;y:=50;
SetColor(11);
SetLineStyle(1,1,1); {Estilo de linea, grosor,}
ARC(245,291,30,300,90);
End;
(**************************************************)
Procedure I;
Begin
x:=0;y:=50;
SetColor(11);
SetLineStyle(1,1,1);
ARC(342,245,180,45,20);
End;
(**************************************************)
Procedure J;
Begin
x:=0;y:=50;
SetColor(11);
SetLineStyle(1,1,1);
ARC(390,230,280,180,35);
End;
(**************************************************)
Procedure K;
Begin
x:=0;y:=50;
SetColor(11);
SetLineStyle(1,1,1);
ARC(400,290,330,100,25);
End;
(**************************************************)
Procedure L;
Begin
x:=0;y:=50;
SetColor(11);
SetLineStyle(1,1,1);
ARC(425,325,370,100,20);
End;
(***********************************************)
Procedure M;
Begin
x:=0;y:=0;
SetColor(11);
SetLineStyle(1,1,3);
For x:=446 Downto 250 Do
begin
line(x,321,x-10,321);
Delay(5);
end;
End;
(**************************************************)
Procedure Texto;
Begin
SetTextStyle(0,0,5);
{Estilo de letra}
outtextXY(250,100,'Mouse'); {Salida de texto}
End;
(**************************************************)
BEGIN
clrscr;
DRVGRAF := DETECT;
{detectar el controlador de graficos}
INITGRAPH(DRVGRAF,MODOGRAF,'C:\pascal'); {iniciar en modo grafico}
CODIGOERROR := GRAPHRESULT;
IF CODIGOERROR <> GROK THEN
{ GROK es igual a Cero, ya
definido}
BEGIN
WRITELN('ERROR
DE
GRAFICOS.',GRAPHERRORMSG(CODIGOERROR));
HALT;
END;
SetLineStyle(1,1,3);
SetColor(10);
A;B;C;D;E;F;G;H;I;J;K;L;M;
Texto;
readln;
CloseGraph;
{cerrar el modo grafico}
end.
Actividad 2: Elaboración de Proyecto.
Elaboración de un Proyecto:
Que deberá entregarse al final del Trimestre
Impreso y en Diskette.
PROYECTO 1.Elaborar un Sistema de cómputo en contabilidad de una Empresa del ramo
ferretero. Donde se involucren: Clientes, empleados, marcas, productos,
ventas, facturas.
PROYECTO 2.Visitar las oficinas de la Comisión Federal de Electricidad en Los Mochis, Sin.
para observar el mecanismo de pago de consumo de electricidad en los
dispositivos de CFEMático de pago automático instalados dentro y fuera de
dichas oficinas. Elaborar de acuerdo con las posibilidades de Pascal algunas
de las opciones que presenta dicho sistema de pago.
Nota.- Se escogerá un proyecto por titular académico en base a la terminación
de su matrícula (Sí es Non el proyecto 1, Par escogerá el proyecto 2).
INTEGRACIÓN CONCEPTUAL:
(El titular académico conocerá las
respuestas) Adquisición de los conocimientos para realizar un análisis y un
diseño correcto de programas que nos ayuden a resolver un problema
utilizando el lenguaje de programación TURBO PASCAL para posteriormente
estar en posición de adecuarlos a los lenguajes más actuales.
---------------------------------------------------------------------------------------------------------REPORTES CRÍTICOS O SUGERENTES A: Ing. Manuel de Jesús
Valdez Acosta, Secretario General. Universidad Autónoma Indígena de México
(Correo electrónico [email protected] ); MC Ernesto Guerra García,
Coordinador General Educativo. (Correo electrónico: [email protected] )
Benito Juárez No. 39, Mochicahui, El Fuerte, Sinaloa, México. C.P. 81890, Tel.
01 (698) 8 92 00 42.
----------------------------------------------------------------------------------------------------------
UNIVERSIDAD AUTÓNOMA INDÍGENA DE MÉXICO
Mochicahui, El Fuerte, Sinaloa
Juárez 39, C.P. 81890. Tel y fax: (698)8 92 00 42 y 8 92 00 23
Correo electrónico:_ [email protected]
Página Web: http//www.uaim.edu.mx