LENGUAJES DE PROGRAMACIÓN

Transcripción

1 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.

2 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. II.3.- Identificadores. II.4.- Palabras reservadas. II.5.- Tipos de datos. III.8.- Cabecera. III.9.- Declaraciones. III.10.- Programa principal. UNIDAD II Elementos Básicos de Turbo Pascal UNIDAD III Estructura de un Programa

3 IV.11.- Instrucciones de salida. IV.12.- Instrucciones de entrada. UNIDAD IV Instrucciones de Entrada / Salida UNIDAD V Condiciones V IF THEN ó IF THEN ELSE. V IF anidadas. V CASE OF. VI.16.- FOR. VI.17.- WHILE. VI.18.- REPEAT-UNTIL. VI.19.- Ciclos anidados. VII.20.- Procedimientos. VII.21.- Funciones. VIII.22.- Archivos directos. Actividad 1: Ejercicios de práctica. Actividad 2: Elaboración de proyecto. UNIDAD VI Ciclos UNIDAD VII Funciones y Procedimientos UNIDAD VIII Archivos ESCENARIOS INFORMATIVOS: Disposición en Internet. Curso de Pascal: Tutorial de Turbo Pascal:

4 Aprendizaje de Pascal: Puntualidad en Intranet. Fuentes Directas e Indirectas. BIBLIOGRAFÍA: Joyanes Aguilar, Luis Programación en Turbo Pascal. Editorial Mc Graw Hill, México, 822 pp. 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.

5 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

6 AND ARRAY 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

7 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 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 * = E-4 = 1.5 * 10^-4 = 1.5 * = 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' '#'

8 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; 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;

9 PROCEDURE, FUNCTION Declaraciones de procedimientos y funciones; 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 = ; De esta forma el identificador pi recibirá el valor de 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

10 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 = ; Nombre = 'Juan Gutiérrez'; Unidad = 1; Otra forma de escribir lo mismo es así: CONST PI = ; 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 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: '; 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

11 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; 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

12 '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 los Write y WriteLn es que esta última imprime el contenido de 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.

13 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 := ; 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

14 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 Ejecutar sentencia ELSE del cierto o falso? Ejecutar sentencia IF...THEN del Continuar con el programa PROGRAM IF_THEN_ELSE; VAR Contador: Integer; FOR contador: = 1 to 50 DO 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

15 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: V.15 CASE OF IF Número > 5 THEN IF Número < 10 THEN Opción := Número; IF Número < 30 THEN Opcion2 := Número; END; 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; 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.

16 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; 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;

17 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; Número := 1; WHILE Número <= 50 DO 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; Número := 1; REPEAT WriteLn (Número); Número := Número + 1;

18 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; TEXTBACKGROUND(BROWN); CLRSCR; GOTOXY(7,9);WRITE('DAME EL TEXTO:'); READLN(NOMBRE); FOR I:=1 TO LENGTH(NOMBRE) DO GOTOXY(20+I,9);WRITE(' '); FOR Y:= 10 TO 18 DO 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.

19 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": Uso de los procedimientos PROCEDURE Titulo; WriteLn ('Programa de Turbo Pascal'); END; 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;

20 WriteLn ('Programa de Turbo Pascal'); END; 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

21 negativo. Program empleados; uses Crt; Type Datos=record cve:byte; nom:string [30]; pago:longint; Var Empleado:File of Datos; em:datos; Op, I:Byte; Len:Integer; Procedure Abrir; var A:Byte; Assign(Empleado,'A:empleado.dat'); {$ I-} Reset(empleado); {$ I+} A:=IORESULT; If A<> 0 then Writeln('Archivo no existe'); Rewrite (empleado); 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;

22 var A:integer; op:char; 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, obtiene el 5% Si la venta > = 1, y < = 3, obtiene el 8% Si la venta es mayor 3, obtiene el 10% 5.- Ejecutar el siguiente programa y hacer las modificaciones pertinentes. Aquí

23 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; Var Empleado:File of Datos; em:datos; op,i:byte; Len:Integer; {***************} Procedure Abrir; Var A:Byte; Assign(Empleado,'C:empleado.Dat'); {$I-} Reset(Empleado); {$I+} A:=IOResult; If A<>0 Then WriteLn('Archivo no Existe'); ReWrite(Empleado); {***************} Procedure Cerrar; Close(empleado); {***************} Procedure Altas; Var cla:byte; B: Boolean; Repeat

24 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 B:=False; For I:=1 To Len Do Seek(empleado,I-1); Read(empleado, em); If em.cve=cla Then 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; If Not B then With em Do GotoXY(10,5);Write('Nombre');Readln(nom); GotoXY(10,6);Write('Pago');Readln(pago); cve:=cla; Write(empleado,em); Until cla=0; {***************} Procedure Bajas; var cla:byte; B:Boolean; Repeat ClrScr; GotoXY(7,2);Write('Bajas'); Len:=FileSize(empleado); GotoXY(10,4);Write('Clave');Readln(cla); If cla<>0 Then B:=False; For I:=1 To Len Do

25 Seek(empleado, I-1); Read(empleado, em); If em.cve=cla Then 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); If Not B Then GotoXY(15,8);WriteLn('Registro No Existe'); Delay(3000); If Not B Then GotoXY(15,8);Write('Registro No existe'); Delay(3000); Until cla=0; {***************} Procedure Consultas; Clrscr; GotoXY(18,15);Write('falta de tu parte terminar este procedimiento'); Readln; {***************} Procedure Reportes; Clrscr; GotoXY(18,15);Write('Aqui es la seccion de mandar a imprimir, opcional'); Readln;

26 {***************} End. 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 Writeln('OPCION NO VALIDA'); Delay(3000); Until op=5 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

27 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; x:=0;y:=0; For x:=425 Downto 50 Do linea(x,50,x-10,50); Delay(200); {trazar linea} (**************************************************) Procedure B; x:=0;y:=0; ARC(45,75,90,180,25); {trazar un arco} (**************************************************) Procedure C; x:=0;y:=0; For y:=75 to 400 Do line(20,y,20,y+10); Delay(150); (**************************************************) Procedure D; x:=0;y:=0; ARC(45,410,180,270,25);

28 (**************************************************) Procedure E; x:=0;y:=0; For x:=55 to 450 Do line(x,435,x-10,435); Delay(100); (**************************************************) Procedure F; x:=0;y:=0; ARC(446,399,270,120,35); (**************************************************) Procedure G; x:=0;y:=0; SetColor(11); SetLineStyle(1,1,1); For x:=430 Downto 300 Do line(x,370,x-10,370); Delay(5); (**************************************************) Procedure H; x:=0;y:=50; SetColor(11); SetLineStyle(1,1,1); {Estilo de linea, grosor,} ARC(245,291,30,300,90); (**************************************************)

29 Procedure I; x:=0;y:=50; SetColor(11); SetLineStyle(1,1,1); ARC(342,245,180,45,20); (**************************************************) Procedure J; x:=0;y:=50; SetColor(11); SetLineStyle(1,1,1); ARC(390,230,280,180,35); (**************************************************) Procedure K; x:=0;y:=50; SetColor(11); SetLineStyle(1,1,1); ARC(400,290,330,100,25); (**************************************************) Procedure L; x:=0;y:=50; SetColor(11); SetLineStyle(1,1,1); ARC(425,325,370,100,20); (***********************************************) Procedure M; x:=0;y:=0; SetColor(11);

30 SetLineStyle(1,1,3); For x:=446 Downto 250 Do line(x,321,x-10,321); Delay(5); (**************************************************) Procedure Texto; SetTextStyle(0,0,5); {Estilo de letra} outtextxy(250,100,'mouse'); {Salida de texto} (**************************************************) 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} 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.

31 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 , Tel. 01 (698) UNIVERSIDAD AUTÓNOMA INDÍGENA DE MÉXICO Mochicahui, El Fuerte, Sinaloa Juárez 39, C.P Tel y fax: (698) y Correo electrónico:_ [email protected] Página Web: http//