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 Introducción a Pascal. Unidad II Elementos básicos de turbo Pascal. Unidad III Estructura de un programa.

Unidad IV Instrucciones de entrada / salida. Unidad V Condiciones. Unidad VI Ciclos. Unidad VII Funciones y procedimientos. Unidad VIII 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.- FOR. VI.17.- WHILE. VI.18.- REPEAT-UNTIL. VI.19.- 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.

0’brien, Stephen. 1992 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 ASM DESTRUCTOR IMPLEMENTATION INTERFACE OBJECT

PRIVATE SHR UNIT VIRTUAL CONSTRUCTOR EXTERNAL INLINE INTERRUPT SHL STRING USES 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 Números enteros sin parte decimal. Char Caracteres del código ASCII Bolean Pueden contener los valores de falso o verdadero Real Números que pueden incluir una parte decimal String 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 con rangos menores nos ofrece una mayor velocidad y menor espacio en memoria, pero si se utilizan enteros largos se cuenta con mayor precisión. Los tipos de enteros en Turbo Pascal son:

Tipo Rango de valores que acepta Integer -32,768 a 32,767 Word 0 a 65535 ShortInt -128 a 127 Byte 0 a 255 LongInt -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 Rango de valores que acepta Real 2.9E-39 a 1.7E38 Single 1.5E-45 a 3.4E38 Double 5.0E-324 a 1.7E308 Extended 1.9E-4851 a 1.1E4932 Comp -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

Las cadenas son secuencias de caracteres o arreglos que tienen una

longitud máxima de 255 caracteres. Se definen entre apóstrofes. El tipo de Pascal para las cadenas es String.

PROGRAM Cadena; VAR Nombre: String; BEGIN Nombre:= 'Ernesto Chávez'; Writeln (Nombre); END.

III.8.- CABECERA.

El lenguaje utilizado en Turbo Pascal es estructurado, lo que significa que 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;

Declaraciones

USES Nombre de unidad1, Nombre de unidad2, .., Nombre de unidadN; LABEL Declaraciones de etiquetas; CONST Declaraciones de constantes; TYPE Declaraciones de tipos definidos por el usuario; VAR Declaraciones de variables;

PROCEDURE, FUNCTION Declaraciones de procedimientos y funciones;

Cuerpo

BEGIN Programa principal ........ 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;

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 en 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

Programa principal después de haber realizado todas las declaraciones se 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 con la palabra END., esta última con un punto al final. Cada línea de código, enunciado, sentencia o instrucción completa que se 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 o 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.

Como podrá apreciarse, no es importante el orden en el que se declaran las 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.

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 los 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);

Si en lugar de utilizar la instrucción Write hacemos uso de WriteLn con la 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

cierto

Expresión

¿cierto o falso?

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:

FALSO CIERTO

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

Expresión booleana

¿cierto o falso? Ejecutar

sentencia del IF...THEN

Continuar con

el programa

Ejecutar

sentencia del

ELSE

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 la variable de archivo y el nombre del archivo en disco. Reset abre un nuevo archivo ó un existente en disco cuando no existe se asocia con el procedimiento Rewrite para generarlo. 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

I – O RESULT función que regresa un valor 0 cuando se abre con éxito el 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 ingvaldez@uaim.edu.mx ); MC Ernesto Guerra García, Coordinador General Educativo. (Correo electrónico: eguerra@uaim.edu.mx ) 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:_ uaim@uaim.edu.mx Página Web: http//www.uaim.edu.mx