Aprender a programar con Turbo Pascal. Turbo pascal

Transcripción

1

2 Aprender a programar con Turbo Pascal Realizar una aplicación que realice la suma de dos números. Program suma; crt; var numero1:integer; numero2:integer; suma:integer; begin clrscr; writeln ('Escriba el primer numero'); readln (numero1); writeln ('Escriba el numero 2 ); readln (numero2); suma := numero1 + numero2; writeln ('El resultado de la suma es:', suma); end. Este pequeño ejemplo nos hace la suma de dos números digitados desde el teclado y luego hace la operación mostrando luego el resultado. Turbo pascal El lenguaje presenta una serie de características que lo hacen el lenguaje perfecto para aquellas personas iniciadas en la programación: 1. Excelente para el aprendizaje de la programación. 2. Lenguaje de propósito general, es decir, se puede aplicar a gran diversidad de aplicaciones. 3. Utilización de procedimiento (programación modular). 4. Lenguaje estructurado, se utilizan secuencias de control de bifurcación y bucles (If, For, While, Repeat) sin necesidad de la famosa instrucción Goto tan utilizada en muchos lenguajes como BASIC. 5. Soporta la recursividad, es decir, propiedad que tienen los procedimientos para llamarse a sí mismo. 6. Tipo de datos simples y estructurados, así como definidos por el usuario. 7. Posibilidad de trabajar con punteros (variables dinámicas), de este modo permite definir nuestras propias estructuras de datos dinámicas (lista, pilas, colas, etc.). Program Nombre; Lista de Librerias; Const Lista de Constantes; Estructura de un Programa en Pascal:

3 Type Lista de tipos de datos; Lista de iables; Sentencias; Veamos un ejemplo de un programa básico, que escribirá en pantalla la palabra Hola: Program Saludo; Write ('Hola'); Lo primero es que la mayoría de las sentencias son palabras en ingles o abreviaturas de estas. Este programa lo podríamos traducir literalmente, de la siguiente manera: Programa Saludo Comienzo Escribe Hola Final La línea Program es opcional y sirve para ponerle un nombre al programa; de esta manera, se tiene una idea de lo que hace el mismo. La palabra Saludo, es el nombre del programa. Las palabras y End marcan el principio y el final del programa. No existe distinción entre mayúsculas y minúsculas, por lo que BEGIN es lo mismo que begin ó. Como podrán ver algunas líneas terminan con un punto y coma. Pues bien, cada sentencia de Pascal debe terminar con un punto y coma (;), salvo el último End, que lo hará con un punto. No es necesario un punto y coma después de un, ni antes de una palabra End o de un Until. Cuando definamos variables, tipos, constantes, etc., veremos que tampoco va punto y coma después de las cabeceras de las declaraciones. Pero eso ya llegará... La orden Write aparece algo más a la derecha que el resto. Esto se llama escritura indentada, y consiste en escribir a la misma altura todos los comandos que se encuentran a un mismo nivel, algo más a la derecha los que están en un nivel inferior, y así sucesivamente, buscando mayor legibilidad. Se irá viendo con más detalle a medida que se avanza en el tutorial. La sentencia Readln, en este caso, nos sirve para que tenga una pausa y uno pueda ver lo que apareció en pantalla, hasta que se presione la tecla <ENTER>.

4 Una línea del programa en Turbo Pascal puede tener hasta 128 caracteres. Sentencias básicas iables: Las variables son muy importantes en todos los programas. Con las variables podrás guardar información relevante con la que podrás operar más tarde. Una variable es simplemente un nombre que das a un área de la memoria en la cual el valor dato es guardado. Cuando necesites sacar esta parte del dato, o modificar este valor, puedes referirte a la localización en memoria por el nombre de la variable. Eres libre de dar a la variable un nombre descriptivo. Por ejemplo el nombre de variable telefono es obvio que contendrá algún tipo de número de teléfono. El nombre de la variable debe ser: 1. El primer carácter deberá ser siempre una letra: mayúscula o minúscula. 2. Después de la primera letra en el nombre de la variable podrá ser letras, números y el guion de abajo (_). 3. El nombre de la variable no puede ser una sentencia, por ejemplo Write. 4. Puede tener cualquier longitud, pero solo 63 son significativos. 5. No puedes usar letras acentuadas, espacios ni la letra ñ. Tipos de Datos: Los tipos de datos de la variable más usados en Turbo Pascal, son los siguientes: 1. Integer: Es un número entero con signo, que puede valer desde hasta Ocupa 2 bytes de memoria. 2. Byte: Es un número entero, que puede valer entre 0 y 255. El espacio que ocupa en memoria es el de 1 byte, como su propio nombre indica. 3. Char: Representa a un carácter (letra, número o símbolo). Ocupa 1 byte. 4. String: Es una cadena de caracteres, empleado para almacenar y representar mensajes de más de una letra (hasta 255). Ocupa 256 bytes. El formato en Pascal es string[n], donde n es la anchura máxima que queremos almacenar en esa cadena de caracteres (de 0 a 255), y entonces ocupará n+1 bytes en memoria. 5. Real: Es un numero real con signo. Puede almacenar números con valores entre 2.9e-39 y 1.7e38. Tendremos 11 o 12 dígitos significativos y ocupan 6 bytes en memoria. 6. Boolean: Es una variable lógica, que puede valer TRUE (verdadero) o FALSE (falso), y se usa para comprobar condiciones.

5 Declaración: Asignación: Numero:integer; Sueldo:real; Nombre, apellido:string[20]; letra:char; Nombre:='Pedro'; Numero:=1; Operaciones Básicas: Operadores Matemáticos: Operadores Descripción + Suma - Resta * Multiplicación / División div División de enteros. Punto decimal mod Resto de la división Sqr Elevar al cuadrado Sqrt Raíz Cuadrada Ln Logaritmo natural Exp Exponencial (e elevado a un número) Sin Seno Cos Coseno ^ Exponente (ALT 094) La barra de división / produce un resultado real independientemente del tipo de sus operandos; es decir, 3/4 produce 0.75, que es real, pero 2/4 produce 2.0, también de manera real, así que el resultado de una división con la barra se debe asignar a una variable real. Para obtener sólo la parte entera de una división, se usa el operador Div. Por ejemplo, 7 Div 3 da como resultado 2 (porque 7 cabe en 3 dos veces); este resultado se puede asignar a una variable entera. Claro que hay una pérdida de precisión en esta operación; puede obtenerse por separado el residuo de la división usando Mod, como en 7 Mod 3, que da por resultado 1. El uso más importante de Mod es para

6 saber si un número dado es múltiplo de otro; en efecto, si A Mod B = 0, entonces A es múltiplo de B. Más adelante se verá cómo realizar decisiones en el programa. 5/2=2,5 ; resto=1 5div2=2 5mod2=1 Operadores de Relación: Los operadores relacionales nos sirven para determinar la relación que tiene una expresión con otra. Los operadores relacionales que manejaremos en Pascal son los siguientes: Operadores Descripción = Es igual a <> No es igual a > Es mayor que < Es menor que >= Es mayor o igual que <= Es menor o igual que And Or Not y o no Write, Read, CRT, CLRSCR: Escribe en Pascal el siguiente programa y luego córrelo: Fíjate bien que después de Hola y antes de la comilla simple hay un espacio, ya veras porque. Program Saludo; nombre: string[20]; Writeln ('Introduce tu nombre, por favor'); Readln (nombre); Write ('Hola ',nombre);

7 En primer lugar, hemos definido una variable, para lo que empleamos la palabra, seguida del nombre que vamos a dar a la variable, y del tipo de datos que va a almacenar esa variable. Con la palabra string decimos que la variable nombre va a contener una cadena de caracteres (letras o números). String[20] indica que el nombre podrá estar formado hasta por 20 letras o números. Write es la orden que permite escribir un texto en pantalla. El conjunto de todo lo que se desee escribir se indica entre paréntesis. Cuando se trata de un texto que queremos que aparezca tal cual, éste se encierra entre comillas (una comilla simple para el principio y otra para el final). Esta vez se ha empleado Writeln, que es exactamente igual que Write con la única diferencia de que después de visualizar el mensaje, el cursor (la posición en la que se seguiría escribiendo, marcada normalmente por una rayita o un cuadrado que parpadea) pasa a la línea siguiente, en vez de quedarse justo después del mensaje escrito. Después se espera a que el usuario introduzca su nombre, gracias a Read, y se guarda automáticamente en la variable nombre. Finalmente, aparece en pantalla la palabra Hola seguida por el nombre que se ha introducido, ósea, Write llama a la variable nombre. Obsérvese la combinación de símbolos := del programa. Es un operador de asignación y sirve, al igual que el ReadLn, para darle valor a una variable. A diferencia del ReadLn, sin embargo, el valor que se da a la variable no se lee del teclado, sino que se toma de una constante, de otra variable, o de una expresión aritmética (situadas a la derecha del operador de asignación) y se copia hacia la variable cuyo nombre está a la izquierda. Otro Ejemplo: Program Suma; {Ejemplo de un programa que Suma} A,B,Resultado:integer; Write ('Ingrese primer numero:'); Readln (A); Write ('Ingrese segundo numero:'); Readln (B); Resultado:=A+B; Writeln ('El Resultado es:',resultado);

8 En este ejemplo lo que hacen las llaves {} es insertar un comentario en nuestro programa. El comentario no será tomando en cuenta por Pascal cuando se corra el programa, solo sirve como referencia para saber, por ejemplo: cuando se hizo, quien lo hizo, para que sirve el programa, para que funciona cada línea, etc. Sirve para comentar tus programas y que otros usuarios lo entiendan. La sentencia CLRSCR, nos permite borrar la pantalla antes de correr el programa. Es primordial limpiar la pantalla cada vez que iniciemos un programa, para que no se vean líneas de programas anteriores. Para que funcione debes colocar la unidad CRT. CRT es la primera unidad que trataremos y es la encargada de gestionar (entre otras cosas) la pantalla en modo texto. Para acceder a cualquier unidad, se emplea la sentencia justo después de Program y antes de las declaraciones de variables: Program Prueba; [...] Otro ejemplo: Program AreaCirculo; Crt; Const pi = ; {Declaración de constante} area: Real; {Area del círculo} radio: Integer; {Radio a teclear} Write ('Radio: '); ReadLn (radio); area := pi * radio * radio; WriteLn ('Area: ', area); La sección llamada Const es para declarar las constantes. Son opcionales. Nótese que a una constante no se le especifica el tipo de variable, sólo el valor. La escritura de una variable Real se produce por defecto en notación científica. Para obviar esto, pueden agregarse al final del nombre de la variable dentro del Write/WriteLn, dos números separados por dos puntos. El primero dice cuántos espacios en blanco insertar delante del número, y el segundo cuántas cifras decimales imprimir: WriteLn('Area: ', area:0:2);

9 If THEN Muchas veces se nos presentan situaciones en las que tenemos que evaluar una condición o situación. Si la condición es verdadera, entonces ejecutamos una o más instrucciones; si no es verdadera, ejecutamos otra u otras instrucciones. Sintaxis: If <cond> then <Bloque de Sentencias>; End Else <Bloque de Sentencias>; Donde <cond> es una condición que puede ser falsa o verdadera, y <bloque de sentencias> es una sola sentencia, o bien varias sentencias encerradas entre un y un El y el End se usan cuando hay mas de una sentencia y Else cuando es necesario. La forma general de una condición es: <expr1><op-rel><expr2> Donde <expr> son expresiones y <op-rel> son los operadores relacionales. Es bueno recalcar que el bloque del If se ejecuta sólo si la condición es verdadera, y que el bloque del Else se ejecuta sólo si la condición es falsa. La línea que está antes del Else no se le coloca punto y coma. Veamos un ejemplo: Program Numeros; numero:integer; Write ('Escriba un número: '); Readln (numero); If numero>0 Then Writeln ('El número es positivo');

10 Otro ejemplo, pero ahora con Else: Program Numeros; numero:integer; Write ('Escriba un número: '); Readln (numero); If numero<0 Then Writeln ('El número es negativo') Else Writeln ('El número es positivo o cero'); El programa pide un número. Si (IF) el número introducido es menor que cero entonces (THEN) se imprime el mensaje El número es negativo. Si no (ELSE), es menor que cero, entonces se imprime el mensaje El número es positivo. Otro ejemplo: Program Mayor; N1,N2,N3,NMayor:integer; Write ('Ingrese primer número: '); Readln (N1); Write ('Ingrese segundo número: '); Readln (N2); Write ('Ingrese tercer número: '); Readln (N3); If (N1>=N2) And (N1>=N3) Then; NMayor:=N1; If (N2>=N1) And (N2>=N3) Then; NMayor:=N2;

11 If (N3>=N1) And (N3>=N2) Then; NMayor:=N3; Writeln ('El numero mayor es: ',NMayor); Otro Ejemplo: Program Formula; x,y,z:real; Write ('Ingrese el valor de y: '); Readln (y); Write ('Ingrese el valor de z: '); Readln (z); If z<>0 Then; x:=y/z; Writeln('x= ',x:8:4); End Else Writeln ('el valor de z debe ser diferente de cero'); Como se ha visto, la sentencia If presenta una forma de tomar decisiones basándose en el resultado de evaluar una expresión condicional. Esto, por supuesto, tiene limitaciones; a veces es necesario evaluar una expresión aritmética en vez de lógica, y tomar varias decisiones según los distintos valores. Si hay muchos valores diferentes posibles, usar If para esto puede ser tedioso. CASE OF Es por esto que la sentencia Case ejecuta condicionalmente uno o más bloques de código de acuerdo con el resultado de una expresión aritmética que produzca un número entero. Su sintaxis es: Case <expr> Of <val1> : <bloq1>; <val2> : <bloq2>;... <val-n> : <bloq-n>; Else

12 <bloq>; Donde <expr> es la expresión a evaluar y <val1>, <val2>,... <val-n> son valores de entre los que puede tomar esa expresión, y para cada valor se ejecutará el bloque correspondiente. Como los valores pueden repetirse, se pueden ejecutar uno o más de los bloques, o bien ninguno. Nótese que el Case termina siempre con un, a pesar de que no tiene. Nótese que la parte del Else es opcional, al igual que en el If, y su bloque asociado sólo se ejecuta si la expresión toma un valor para el cual no se ha especificado un bloque de código. Sin embargo, si se usara el Else, el último bloque sobre él debe llevar un punto y coma al final de su última línea, a diferencia de como es en el If. Veamos el siguiente ejemplo: Program Case; opcion:char; Writeln ('Opción: 1 '); Writeln ('Opción: 2 '); Writeln ('Opción: 3 '); Write ('Escoge una opción: '); Readln (opcion); Case opcion Of '1': Writeln ('Escogiste la opción: 1'); '2': Writeln ('Escogiste la opción: 2'); '3': Writeln ('Escogiste la opción: 3'); Else Writeln ('Escogiste una opción no valida'); El ejemplo anterior nos presenta un pequeño menú con 3 opciones a escoger, si escogemos la opción 1, y por tanto le damos a la variable opcion el valor de uno, entonces se ejecutaron las instrucciones que corresponden al caso de que la variable sea igual a 1, si escogemos la opción 2, entonces se ejecutarán las instrucciones que corresponden al caso de que la variable sea igual a 2, etc. Dentro de cada caso que tenga la expresión podemos ejecutar una o más instrucciones, incluyendo bloques If y anidar bloques Case si nos fuera necesario.

13 Otro ejemplo: Program Directorio; Crt; Piso: Integer; Negocio: String; Write ('Número de piso: '); Readln (Piso); Case Piso Of 1: Negocio:= 'Microsoft'; 2: Negocio:= 'Compaq'; If Negocio <> '' Then Writeln ('El negocio en el piso ', Piso, ' es: ', Negocio) Else Writeln ('Este edificio sólo tiene dos pisos'); El programa trabaja como sigue: según sea el piso escogido, se guardan los nombres de los negocios en ese piso en una variable de tipo String. Luego, se consulta el valor de esa variable: si es nula (''), no se le asignó valor en el Case y entonces el número de piso no es válido y se imprime el mensaje del Else. En caso contrario, se muestran los negocios en ese piso. Sin embargo, esta no es más que una pequeña muestra en el poder del Case. En efecto, una extensión a su sintaxis de valores le permite ejecutar un mismo bloque de código para un rango de valores de la expresión: Case X Of 1..5 : Write ('Entre 1 y 5'); 7 : Write ('Siete'); La idea es colocar dos expresiones separadas por punto punto (..); si el valor de la expresión evaluada por el Case (en este caso el valor de la variable X) está comprendido en este rango, se ejecuta este bloque. Una última consideración sobre el Case es que la expresión a ser evaluada debe producir siempre un resultado entero, o un carácter: Case X Of 'A'..'Z', 'a'..'z': Write ('Letra'); '0'..'9' : Write ('Número');

14 Else Write ('Carácter especial'); Aquí a es una variable del tipo Char. Como se ve además en este ejemplo, se pueden colocar más de un rango en un solo bloque, como se ha hecho con las letras (ya que la computadora interpreta las mayúsculas y las minúsculas de formas distintas). Otro ejemplo: Program Case; letra:char; Write ('Escriba un símbolo: '); Readln (letra); Case letra Of ' ': Writeln ('Un espacio'); 'A'..'Z', 'a'..'z': Writeln ('Una letra'); '0'..'9': Writeln ('Un dígito'); '+', '-', '*', '/': WriteLn('Un operador'); Else Writeln ('No es espacio, ni letra, ni dígito, ni operador'); Otro ejemplo: Program Areas; area,l,b,n:real; opcion:integer; Writeln ('1.- Area Triangulo'); Writeln ('2.- Area Rectángulo'); Writeln ('3.- Area Cuadrado'); Writeln ('4.- Salir');

15 Write ('Ingrese opción: '); Readln (opcion); Case opcion Of 1: Write ('Ingrese base: '); Readln (B); Write ('Ingrese altura: '); Readln (N); area:=(b*n)/2; Writeln ('El Area es: ',area:8:4); 2: Write ('Ingrese base: '); Readln (B); Write ('Ingrese altura: '); Readln (N); area:=b*n; Writeln ('El Area es: ',area:8:4); 3: Write ('Ingrese lado: '); Readln (L); area:=sqr(l); Writeln ('El Area es: ',area:8:4); 4: Writeln ('Hasta luego'); Else Writeln ('Opcion Invalida'); For TO DO La primera forma de repetir código que se verá lo hace mediante un conteo aritmético. Es la sentencia For, que tiene la siguiente sintaxis formal: For <vc>:=<vi> To <vf> Do <sentencia>; For <vc>:=<vi> DownTo <vf> Do <sentencia>; Donde <vc> es una variable contadora de tipo entero, <vi> es un valor inicial para dicha variable y <vf> es un valor final. El valor inicial se asigna a a la variable contadora, que después se incrementa en uno (si se usa To) o se decrementa en uno (si se usa DownTo) cada vez que se corre el bloque. Si se usa To, esto se repite hasta que el valor de la variable contadora exceda el valor final. Si se usa el DownTo

16 (segunda forma), esto se repite hasta que el valor de la variable contadora sea menor que el valor final. En general, el bloque se repite (<vf> - <vi> + 1) veces. De la observación de la manera en que la variable contadora es manipulada según se use la opción To o DownTo, se desprende la siguiente regla: En caso de usar To, el valor inicial debe ser menor que el valor final; en caso de usar DownTo, el valor inicial debe ser mayor que el valor final. Si no se cumple con esto, el bloque del For no correrá jamás. Si hay que colocar mas de una sentencia en For, se deben de colocar entre un y un. Veamos el siguiente ejemplo: For i := 1 To 5 Do Writeln (i); Este fragmento imprime los números desde el 1 hasta el 5. Otro ejemplo: Program Area; area,b,h:real; i,num:integer; Writeln (' Cuantas areas desea calcular?'); Readln (num); For i:=1 To num Do Writeln ('Triangulo #: ',i); Writeln ('Ingrese base: '); Readln (B); Write ('Ingrese altura: '); Readln (H); area:=(b*h)/2; Writeln ('El Area es: ',area:8:4); Otro ejemplo:

17 Program Sumar; N,num,cont,suma:integer; Writeln (' Cuantas números desea ingresar?'); Readln (N); suma:=0; For cont:=1 To N Do Write ('Ingrese numero: ') Readln (num); suma:=suma+num; Writeln ('La suma total es: ',suma); Otro ejemplo: Program For; letra:char; For letra:='a' To 'z' Do Writeln (letra); While DO La idea del While es repetir un bloque de código hasta que una condición dada sea falsa y mientras sea verdadera. Su sintaxis formal es: While <cond> Do <bloque>;

18 Si hay que colocar mas de una sentencia en While, se deben de colocar entre un y un. Veamos el siguiente ejemplo: Program Suma; N,num,cont,suma:integer; Write (' Cuantos numeros desea ingresar?'); Readln (N); suma:=0; cont:=1; While cont<=n Do Write ('Ingrese Numero:'); Readln (num); suma:=suma+num; cont:=cont+1; Writeln ('La suma total es: ',suma); Repeat UNTIL El Repeat repite el bloque hasta que una condición dada sea verdadera y mientras sea falsa. Su sintaxis formal es: Repeat <bloque> Until <cond>; Una cosa muy interesante del Repeat es que puede manejar un bloque sin ni, a diferencia de los demás comandos de Pascal; esto es, se pueden poner tantas líneas de código como se desee entre el Repeat y el Until y todas se repetirán. <cond> es una condición que se estructura de manera similar a la de las condiciones del If; cuando es verdadera, cesa la repetición del bloque. Nótese que la condición que detiene al Repeat no se revisa sino hasta el final del bloque; por tanto, éste correrá siempre al menos una vez.

19 Veamos el siguiente ejemplo: Program Suma; N,num,cont,suma:integer; Write (' Cuantos numeros desea ingresar?'); Readln (N); suma:=0; cont:=1; Repeat Write ('Ingrese Numero:'); Readln (num); suma:=suma+num; cont:=cont+1; Until cont>n; Writeln ('La suma total es: ',suma); Procedimiento y función La programación estructurada trata de dividir el programa en bloques más pequeños, buscando una mayor legibilidad, y más comodidad a la hora de corregir o ampliar. Estos bloques serán de dos tipos: procedimientos (procedure) y funciones (function). La diferencia entre ellos es que un procedimiento ejecuta una serie de acciones que están relacionadas entre sí, y no devuelve ningún valor, mientras que la función sí va a devolver valores. Procedimiento: Su sintaxis es la siguiente: Procedure identificador (parámetros); iables locales; Sentencias; Veamos este ejemplo:

20 Program Acceso; Const ClaveCorrecta = 1 (Esta constante es global) Procedure Password; clave:integer; (Esta variable es local) Writeln ('Introduzca su clave de acceso'); Readln (clave); If clave<>clavecorrecta then Writeln ('La clave no es correcta!'); Exit Password; Un procedimiento puede tener sus propias variables, que llamaremos variables locales, frente a las del resto del programa, que son globales. Desde dentro de un procedimiento podemos acceder a las variables globales (como ClaveCorrecta del ejemplo anterior), pero desde fuera de un procedimiento no podemos acceder a las variables locales que hemos definido dentro de él. La orden Exit, que no habíamos visto aún, permite interrumpir la ejecución del programa (o de un procedimiento) en un determinado momento. Veamos este otro ejemplo: Program Numeros; Procedure Inicio(X1,Y1,Z1:integer); X:=X1; Y:=Y1; Z:=Z1 Inicio(1,2,3);

21 Writeln ('X=', X, ' Y=', Y, ' Z=', Z'); Inicio(4,5,6); Writeln ('X=', X, ' Y=', Y, ' Z=', Z'); Función: Su sintaxis es la siguiente: Procedure identificador (parámetros): tipo; iables locales; Sentencias; Veamos este ejemplo: Program Sumatoria; Z:integer; Function Suma (X1, X2 : integer) : integer; Suma:= X1 + X2; Z:=Suma(1,1); Writeln ('1+1=',Z); Z:=Suma(2,2); Writeln ('2+2=',Z); Parámetros: Las funciones y procedimientos normalmente las trabajamos con variables globales, limitando su campo de acción. Con el uso de parámetros logramos indicar los valores y variables iniciales de los procesos, logrando una mayor flexibilidad y portabilidad. Contamos con dos tipos de parámetros:

22 Parámetros por valor: Cuando se pasa un parámetro por valor, se obtiene una copia temporal de la variable usada, dentro de la función o procedimiento se trabaja con la copia obtenida, no importando las operaciones que se realicen con la copia, la variable introducida como parámetro, no será afectada en su valor inicial al terminar el proceso. Su sintaxis es la siguiente: Procedure identificador (variable: Tipo); Veamos este ejemplo: Program PruebaDeParametros; dato:integer; Procedure Modifica(variable:integer); variable:=3; Writeln ('Dentro: ', variable); dato:=2; Writeln ('Antes: ', dato); Modifica (dato); Writeln ('Después: ', dato); Qué diríais que pasa?, al finalizar escribirá el valor dato... 3? PUES NO!!!! Escribe un 2. Las modificaciones que hagamos a dato dentro del procedimiento Modifica sólo son válidas mientras estemos dentro de ese procedimiento. Daos cuenta de que lo que modificamos es la variable genérica que hemos llamado variable, y que no existe fuera del procedimiento. Eso es pasar un parámetro por valor. Pero, cómo hacemos si realmente queremos modificar el parámetro?. Pues nada más que añadir la palabra delante de cada parámetro que queremos permitir que se pueda modificar. Parámetro por referencia: Cuando se pasa un parámetros por referencia, los cambios que se realicen a la variable introducida como parámetro, se mantendrán vigentes al terminar el proceso, en este caso específico solo se admiten variables. Su sintaxis es la siguiente:

23 Procedure identificador ( variable: Tipo); Veamos este ejemplo: Program PruebaDeParametros; dato:integer; Procedure Modifica( variable:integer); variable:=3; Writeln ('Dentro: ', variable); dato:=2; Writeln ('Antes: ', dato); Modifica (dato); Writeln ('Después: ', dato); Esta vez la última línea del programa sí que escribe un 3 y no un 2, porque hemos permitido que los cambios hechos a la variable salgan del procedimiento. Esto es pasar un parámetro por referencia. Cadenas de caracteres Las cadenas de caracteres son secuencias de caracteres con longitudes que varían desde 1 hasta los 255 caracteres. El tipo identificador de las cadenas es String. Cuando declaramos una variable de tipo String será posible introducir hasta 255 caracteres en ella, pero también es factible declarar cadenas más cortas agregando al momento de la declaración la longitud de la variable, por ejemplo: mensaje : String[30]; {longitud maxima de la cadena = 30 caracteres} Comparación de cadenas: La comparación de cadenas es una operación muy común en Pascal; estas comparaciones se realizan con base en el orden del código ASCII, por ejemplo la cadena Prueba es menor a la cadena prueba ya que el valor del código ASCII de P es 80 y el de p es 112. Así también podemos diferenciar las cadenas con respecto a su tamaño: Hola es menor a Bienvenido. Existe un caso especial de una cadena, que es cuando no tiene ningún carácter en ella, en ese momento decimos que es una cadena nula o vacía. Se recomienda ampliamente inicializar todos los valores de las cadenas a cadenas nulas al inicio del programa, ya que podrían contener datos extraños e indeseables.

24 Manejo de los elementos de la cadena: Es posible leer cada elemento de una cadena por separado, por ejemplo, si en la variable Calle almacenamos la cadena Hidalgo es posible asignar a otra cadena el valor de Calle[x] donde x es el carácter de la cadena que se quiere leer, así también es posible visualizar el carácter en pantalla usando la instrucción WriteLn. Ejemplo: Program Cadena; Calle : String; Letra : String; Calle := 'Caracas'; WriteLn (Calle[2]); {Visualiza el segundo caracter de Calle} Letra := Calle[1]; {Guarda en Letra el primer caracter de Calle} WriteLn (Letra); Length: Para conocer la longitud de una cadena utilizamos la función Length, la longitud es la cantidad de caracteres que contiene la cadena en un momento determinado. Su sintaxis es: Length (cadena); La función regresa un valor entero. Program Length; Cadena : String; Cadena := 'Prueba de longitud'; WriteLn ('Longitud de la cadena: ', Length (Cadena);

25 El programa imprime en la pantalla un mensaje con la longitud de la cadena almacenada en memoria, en este caso específico 18. Operador (+): Es una de las formas más sencillas de unir dos cadenas y se maneja exactamente como una suma, la única limitante es que en caso de ser mayor la longitud resultante de la suma que la longitud que pueda manejar la variable en que se almacenará se truncarán los caracteres sobrantes. Ejemplo: Program unir cadenas; Cadena1, Cadena2, Cadena3 : String; Cadena1 := 'Buenos '; Cadena2 := 'dias '; Cadena3 := Cadena1 + Cadena2; WriteLn (Cadena3); Se imprimirá en la pantalla: Buenos dias. Concat: La función Concat produce los mismos resultados que la concatenación, es posible incluir cualquier número de cadenas que se necesiten concatenar. La suma de las cadenas no deberá sobrepasar la longitud que la variable, a la cual se asignará dicha suma, puede manejar. Ejemplo: Cadena := Concat (cad1, cad2, cad3,..., cadn); Pos: La función Pos nos sirve para localizar una determinada cadena dentro de otra, en otras palabras para verificar si una cadena es subcadena de otra segunda. Los parámetros que requiere son: la cadena que se buscará y la cadena donde se buscará la primera. Pos (cadbusqueda, cadfuente); Cuando encuentra la cadena la función devuelve su posición inicial, en caso de que no la encuentre devuelve el valor de 0.

26 Ejemplo: Program Pos; Cadena : String; Cadena := 'Domingo Lunes Martes Miercoles Jueves Viernes Sabado'; WriteLn (Cadena); WriteLn (Pos ('Lunes', Cadena)); {Muestra 9} WriteLn (Pos ('Jueves', Cadena)); {Muestra 32} WriteLn (Pos ('Ayer', Cadena)); {Muestra 0} Copy: La función Copy regresa una subcadena de una variable o constante dada como parámetro. Su sintaxis es: Copy (Cadena, Inicio, Cantidad); Donde Cadena es la fuente de la subcadena, Inicio es la posición desde la cual se obtendrá la subcadena y Cantidad es el número de caracteres que se extraerán. Los valores de Inicio y Cantidad deben ser de tipo entero. Ejemplo: Program Pos; Cadena : String; Cadena := "Nuevos horizontes"; WriteLn (Copy (Cadena, 8, 10)); {Visualiza en pantalla: horizontes}

27 Insert: El procedimiento Insert sirve para insertar una cadena dentro de otra en alguna posición determinada. Sintaxis: Insert (Cadena1, Cadena2, Posición) Donde Cadena1 es la que se insertará, Cadena2 es donde se insertará y Posición es el lugar donde se insertará. El parámetro Posición debe ser de tipo entero. Delete: Este procedimiento elimina un determinado número de caracteres de una cadena. Su sintaxis es: Delete (Cadena, Inicio, Número) Cadena es la variable en la cual se eliminarán los caracteres, Inicio es la posición del primer caracter a eliminar y Número es la cantidad de caracteres que se borrarán. UpCase: La función UpCase regresa la letra mayúscula correspondiente al caracter dado como parámetro. UpCase (Cadena) Es muy común trabajando con cadenas que se quiera convertir una que contiene un número a su valor numérico, para poder utilizarlo en operaciones matemáticas, así como convertir un número a su equivalente en una cadena. Esto es más fácil de entender si consideramos que no es lo mismo el valor 75 y el valor '75', en el primer caso es un número mientras que en el segundo es un par de caracteres ASCII. Para lograr estos cambios de tipo en Pascal utilizamos los procedimientos siguientes: Str: El procedimiento Str obtiene una cadena a partir de un valor numérico. Su sintaxis es: Str (Valor, Cadena) Donde Valor es el número a convertir y Cadena es la variable donde se almacenará la cadena ya convertida. Val: Este procedimiento convierte una cadena en un valor de tipo numérico, el problema con esta función es que si la cadena no esta formada exclusivamente de números siguiendo las reglas para el tipo de datos que se vallan a obtener se generará un error. Sintaxis:

28 Val (Cadena, Num, Código) Cadena contiene la cadena que será procesada, Num es la variable de tipo numérico donde se guardará el valor de la cadena y Código es una variable de tipo entero (Integer) que contendrá el valor de 0 si no hubo errores y un valor diferente en caso de que no se haya podido convertir la cadena, el valor de Código representa la posición de la cadena donde ocurrió el error. Ejemplos: Program Invertir; Type Cadena : String[30]; Cadorig, Cadinv : Cadena; Function invierte-cadena (cad1 : Cadena) : Cadena; Longcad, i : integer; cad2 : cadena; Longcad := Length (cad1); cad2 := ' '; For i := Longcad down to 1 do cad2 := cad2 + Copy (cad1, i, 1); invierte-cadena := cad2; Write ('Ingrese Cadena: '); ReadLn (Cadorig); Cadinv := invierte-cadena (Cadorig); WriteLn ('La cadena invertida de ', Cadorig, 'es: ', Cadinv); Otro Ejemplo: Program Contarletras; Type Cadena : String[30]; Caracter : String[1];

29 Cad : Cadena; Letra : Caracter; TotalLetras : Integer; Function CuantasLetras (Cad : Cadena; Letra : Caracter) : Integer; Longcad, i, TotLetras: integer; TotLetras := 0; Longcad := Length (Cad); For i := 1 to Longcad do If UpCase (Letra) = UpCase (Copy (Cad, i, 1)) Then TotLetras := TotLetras + 1; CuantasLetras := TotLetras; Write ('Ingrese Cadena: '); ReadLn (Cad); Write ('Ingrese letra a buscar: '); ReadLn (Letra); TotalLetras := CuantasLetras (Cad, Letra); WriteLn (Letra, ' se encuentra ', TotalLetras, ' veces en ', Cad); Otro Ejemplo: Program Unir Cadenas; Type Cadena : String[30]; Cad1, Cad2, Cadresultante : Cadena; Function Intercalar-cadenas (CadA, CadB : Cadena) : Cadena; Longcad, i : integer; CadR : Cadena; Longcad : Length (CadA);

30 CadR := ' '; For i := 1 to Longcad do CadR := CadR + Copy (CadA, i, 1) + Copy (CadB, i, 1); Intercalar-cadenas := CadR; Write ('Ingrese Cadena1: '); ReadLn (Cad1); Write ('Ingrese Cadena2: '); ReadLn (Cad2); If Length (Cad1) = Length (Cad2) Then Cadresultante := Intercalar-cadenas (Cad1, Cad2); WriteLn ('La cadena intercalada es: ', Cadresultante); End Else WriteLn ('Las cadenas deben ser del mismo tamaño'); Otro Ejemplo: Program Contar Vocales; Type Cadena : String[30]; Cad : Cadena; TotalLetras : Integer; Function CuantasLetras (Cad : Cadena) : integer; Longcad, i, TotLetras : integer; TotLetras := 0; Longcad := Length (Cad); For i := 1 to Longcad do If (UpCase (Copy (Cad, i, 1)) = 'A' ) or (UpCase (Copy (Cad, i, 1)) = 'E' ) or (UpCase (Copy (Cad, i, 1)) = 'I' ) or (UpCase (Copy (Cad, i, 1)) = 'O' ) or (UpCase (Copy (Cad, i, 1)) = 'U' ) Then

31 TotLetras := ToTLetras + 1; CuantasLetras := TotLetras; Write ('Ingrese Cadena: '); ReadLn (Cad); TotalLetras := CuantasLetras (Cad); Write ('existen ', TotalLetras, ' vocales en ', Cad); Otro Ejemplo: Program SustituirLetras; Type Cadena : String[30]; Caracter : String[1]; Cad : Cadena; LetraVieja, LetraNueva : Caracter; Function CambiarLetra (Cad : Cadena; LetraV, LetraN : Caracter) : Cadena; Longcad, i : Integer; cadaux : Cadena; cadaux := ' '; For i := 1 to Longcad do If UpCase (LetraV) = UpCase (Copy (Cad, i, 1)) Then cadaux := cadaux + LetraN Else cadaux := cadaux + Copy (Cad, i, 1); CambiarLetra := cadaux; Write ('Ingrese Cadena: '); ReadLn (Cad);

32 Write ('Ingrese letra a buscar: '); ReadLn (LetraVieja); Write ('Ingrese nueva letra: '); ReadLn (LetraNueva); Cad := CambiarLetra (Cad, LetraVieja, LetraNueva); Write ('La Cadena es: ', Cad); Otro Ejemplo: Program IntercalaCarater; Type Cadena : String[60]; Caracter : String[1]; Cad1, Cadresultante : Cadena; Letra : Caracter; Intervalo : Integer; Function Inserta-Caracter (CadA : Cadena; CadB : Caracter; Num : Integer) : Cadena; Longcad, i : Integer; CadR : Cadena; Longcad := Length (CadA); CadR := ' '; For i := 1 to Longcad do If (i mod Num) = 0 Then CadR := CadR + Copy (CadA, i, 1) + CadB Else CadR := CadR + Copy (CadA, i, 1) Inserta-Caracter := CadR; Write ('Ingrese Cadena: '); ReadLn (Cad1); Write ('Ingrese caracter a insertar: '); ReadLn (Letra); Write ('Ingrese intervalo: ');

33 ReadLn (Intervalo); Cadresultante := Inserta-Caracter (Cad1, Letra, Intervalo); Write ('La Cadena resultante es: ', Cadresultante);