• No se han encontrado resultados

Aprender a programar con Turbo Pascal. Turbo pascal

N/A
N/A
Protected

Academic year: 2021

Share "Aprender a programar con Turbo Pascal. Turbo pascal"

Copied!
33
0
0

Texto completo

(1)
(2)

Aprender a programar con Turbo Pascal

Realizar una aplicación que realice la suma de dos números.

Program suma; Uses 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.).

Estructura de un Programa en Pascal:

Program Nombre; Uses

Lista de Librerias; Const

(3)

Type

Lista de tipos de datos; Var

Lista de Variables; Begin

Sentencias; End.

Veamos un ejemplo de un programa básico, que escribirá en pantalla la palabra Hola:

Program Saludo; Begin

Write ('Hola'); Readln;

End.

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 Begin 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 ó 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 Begin, 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

Variables:

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 -32768 hasta 32767. 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:

Var

Numero:integer;

Sueldo:real;

Nombre, apellido:string[20];

letra:char; Asignación: 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 y

Or o

Not 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; Var

nombre: string[20]; Begin

Writeln ('Introduce tu nombre, por favor'); Readln (nombre);

Write ('Hola ',nombre); Readln;

(7)

En primer lugar, hemos definido una variable, para lo que empleamos la palabra Var, 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} Uses CRT;

Var

A,B,Resultado:integer; Begin

CLRSCR;

Write ('Ingrese primer numero:'); Readln (A);

Write ('Ingrese segundo numero:'); Readln (B);

Resultado:=A+B;

Writeln ('El Resultado es:',Resultado); Readln;

(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 Uses justo después de Program y antes de las declaraciones de variables:

Program Prueba; Uses CRT; Var [...] Otro ejemplo: Program AreaCirculo; Uses Crt; Const pi = 3.1415927; {Declaración de constante} Var

area: Real; {Area del círculo} radio: Integer; {Radio a teclear} Begin

Write ('Radio: '); ReadLn (radio);

area := pi * radio * radio; WriteLn ('Area: ', area); End.

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:

(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 Begin <Bloque de Sentencias>; End Else Begin <Bloque de Sentencias>; End;

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 Begin y un End. El Begin 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; Uses CRT; Var numero:integer; Begin CLRSCR;

Write ('Escriba un número: '); Readln (numero);

If numero>0 Then

Writeln ('El número es positivo'); Readln;

(10)

Otro ejemplo, pero ahora con Else: Program Numeros; Uses CRT; Var numero:integer; Begin CLRSCR;

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'); Readln;

End.

· 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; Uses CRT; Var N1,N2,N3,NMayor:integer; Begin CLRSCR;

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); Readln; End. Otro Ejemplo: Program Formula; Uses CRT; Var x,y,z:real; Begin CLRSCR;

Write ('Ingrese el valor de y: '); Readln (y);

Write ('Ingrese el valor de z: '); Readln (z); If z<>0 Then; Begin x:=y/z; Writeln('x= ',x:8:4); End Else

Writeln ('el valor de z debe ser diferente de cero'); Readln;

End.

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

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 End;, a pesar de que no tiene Begin.

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; Uses CRT; Var opcion:char; Begin CLRSCR; 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'); End;

Readln; End.

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; Uses Crt; Var Piso: Integer; Negocio: String; Begin

Write ('Número de piso: '); Readln (Piso); Case Piso Of 1: Negocio:= 'Microsoft'; 2: Negocio:= 'Compaq'; End; If Negocio <> '' Then

Writeln ('El negocio en el piso ', Piso, ' es: ', Negocio) Else

Writeln ('Este edificio sólo tiene dos pisos'); End.

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'); End;

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'); End;

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; Uses CRT; Var letra:char; Begin CLRSCR;

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'); End; Readln; End. Otro ejemplo: Program Areas; Uses CRT; Var area,L,B,N:real; opcion:integer; Begin CLRSCR;

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: Begin

Write ('Ingrese base: '); Readln (B);

Write ('Ingrese altura: '); Readln (N);

area:=(B*N)/2;

Writeln ('El Area es: ',area:8:4); End;

2: Begin

Write ('Ingrese base: '); Readln (B);

Write ('Ingrese altura: '); Readln (N);

area:=B*N;

Writeln ('El Area es: ',area:8:4); End;

3: Begin

Write ('Ingrese lado: '); Readln (L);

area:=Sqr(L);

Writeln ('El Area es: ',area:8:4); End;

4: Writeln ('Hasta luego'); Else

Writeln ('Opcion Invalida'); End;

Readln; End.

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 Begin y un End;. 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; Uses CRT; Var area,B,H:real; i,num:integer; Begin CLRSCR;

Writeln ('¿Cuantas areas desea calcular?'); Readln (num);

For i:=1 To num Do Begin

Writeln ('Triangulo #: ',i); Writeln ('Ingrese base: '); Readln (B);

Write ('Ingrese altura: '); Readln (H);

area:=(B*H)/2;

Writeln ('El Area es: ',area:8:4); End;

Readln; End.

(17)

Program Sumar; Uses

CRT; Var

N,num,cont,suma:integer; Begin

CLRSCR;

Writeln ('¿Cuantas números desea ingresar?'); Readln (N);

suma:=0;

For cont:=1 To N Do Begin

Write ('Ingrese numero: ') Readln (num);

suma:=suma+num; End;

Writeln ('La suma total es: ',suma); Readln; End. Otro ejemplo: Program For; Uses CRT; Var letra:char; Begin CLRSCR; For letra:='a'To 'z' Do Writeln (letra); Readln; End.

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 Begin y un End;. Veamos el siguiente ejemplo:

Program Suma; Uses

CRT; Var

N,num,cont,suma:integer; Begin

CLRSCR;

Write ('¿Cuantos numeros desea ingresar?'); Readln (N);

suma:=0; cont:=1;

While cont<=N Do Begin

Write ('Ingrese Numero:'); Readln (num);

suma:=suma+num; cont:=cont+1; End;

Writeln ('La suma total es: ',suma); Readln;

End.

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 Begin ni End;, 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; Uses

CRT; Var

N,num,cont,suma:integer; Begin

CLRSCR;

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

End.

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

Variables locales; Begin

Sentencias; End;

(20)

Program Acceso; Uses

CRT; Const

ClaveCorrecta = 1 (Esta constante es global)

Procedure Password; Var

clave:integer; (Esta variable es local)

Begin

Writeln ('Introduzca su clave de acceso'); Readln (clave);

If clave<>ClaveCorrecta then Begin

Writeln ('La clave no es correcta!'); Exit End; End; Begin CLRSCR; Password; Readln; End.

 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; Uses

CRT;

Procedure Inicio(X1,Y1,Z1:integer); Begin X:=X1;Y:=Y1; Z:=Z1 End; Begin CLRSCR; Inicio(1,2,3);

(21)

Writeln ('X=',X, ' Y=', Y, ' Z=',Z'); Inicio(4,5,6); Writeln ('X=',X, ' Y=', Y, ' Z=',Z'); Readln; End.

Función:

Su sintaxis es la siguiente:

Procedure identificador (parámetros): tipo; Var

Variables locales; Begin

Sentencias; End;

Veamos este ejemplo:

Program Sumatoria; Uses

CRT; Var

Z:integer;

Function Suma (X1, X2 : integer) : integer; Begin Suma:= X1 + X2; End; Begin CLRSCR; Z:=Suma(1,1); Writeln ('1+1=',Z); Z:=Suma(2,2); Writeln ('2+2=',Z); Readln; End.

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.

(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; Var

dato:integer;

Procedure Modifica(variable:integer); Begin

variable:=3;

Writeln ('Dentro: ', variable); End;

Begin dato:=2;

Writeln ('Antes: ', dato); Modifica (dato);

Writeln ('Después: ', dato); End.

¿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 Var 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 (Var variable: Tipo); Veamos este ejemplo:

Program PruebaDeParametros; Var

dato:integer;

Procedure Modifica(Var variable:integer); Begin

variable:=3;

Writeln ('Dentro: ', variable); End;

Begin dato:=2;

Writeln ('Antes: ', dato); Modifica (dato);

Writeln ('Después: ', dato); End.

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; Uses CRT; Var Calle : String; Letra : String; Begin CLRSCR; Calle := 'Caracas';

WriteLn (Calle[2]); {Visualiza el segundo caracter de Calle} Letra := Calle[1]; {Guarda en Letra el primer caracter de Calle} WriteLn (Letra);

Readln; End.

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; Uses CRT; Var Cadena : String; Begin CLRSCR;

Cadena := 'Prueba de longitud';

WriteLn ('Longitud de la cadena: ', Length (Cadena); Readln;

(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; Uses

CRT; Var

Cadena1, Cadena2, Cadena3 : String; Begin

CLRSCR;

Cadena1 := 'Buenos '; Cadena2 := 'dias ';

Cadena3 := Cadena1 + Cadena2; WriteLn (Cadena3);

Readln; End.

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; Uses CRT; Var Cadena : String; Begin CLRSCR;

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} Readln;

End.

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; Uses CRT; Var Cadena : String; Begin CLRSCR;

Cadena := "Nuevos horizontes";

WriteLn (Copy (Cadena, 8, 10)); {Visualiza en pantalla: horizontes} Readln;

(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; Uses CRT; Type Cadena : String[30]; Var

Cadorig, Cadinv : Cadena;

Function invierte-cadena (cad1 : Cadena) : Cadena; Var

Longcad, i : integer; cad2 : cadena; Begin

Longcad := Length (cad1); cad2 := ' ';

For i := Longcad down to 1 do cad2 := cad2 + Copy (cad1, i, 1); invierte-cadena := cad2;

End; Begin

CLRSCR;

Write ('Ingrese Cadena: '); ReadLn (Cadorig);

Cadinv := invierte-cadena (Cadorig);

WriteLn ('La cadena invertida de ', Cadorig, 'es: ', Cadinv); Readln; End. Otro Ejemplo: Program Contarletras; Uses CRT; Type Cadena : String[30]; Caracter : String[1];

(29)

Var

Cad : Cadena; Letra : Caracter; TotalLetras : Integer;

Function CuantasLetras (Cad : Cadena; Letra : Caracter) : Integer; Var

Longcad, i, TotLetras: integer; Begin

TotLetras := 0;

Longcad := Length (Cad); For i := 1 to Longcad do Begin

If UpCase (Letra) = UpCase (Copy (Cad, i, 1)) Then TotLetras := TotLetras + 1; End; CuantasLetras := TotLetras; End; Begin CLRSCR;

Write ('Ingrese Cadena: '); ReadLn (Cad);

Write ('Ingrese letra a buscar: '); ReadLn (Letra);

TotalLetras := CuantasLetras (Cad, Letra);

WriteLn (Letra, ' se encuentra ', TotalLetras, ' veces en ', Cad); Readln;

End.

Otro Ejemplo:

Program Unir Cadenas; Uses

CRT; Type

Cadena : String[30]; Var

Cad1, Cad2, Cadresultante : Cadena;

Function Intercalar-cadenas (CadA, CadB : Cadena) : Cadena; Var

Longcad, i : integer; CadR : Cadena; Begin

(30)

CadR := ' ';

For i := 1 to Longcad do

CadR := CadR + Copy (CadA, i, 1) + Copy (CadB, i, 1); Intercalar-cadenas := CadR;

End; Begin

CLRSCR;

Write ('Ingrese Cadena1: '); ReadLn (Cad1);

Write ('Ingrese Cadena2: '); ReadLn (Cad2);

If Length (Cad1) = Length (Cad2) Then Begin

Cadresultante := Intercalar-cadenas (Cad1, Cad2); WriteLn ('La cadena intercalada es: ', Cadresultante); End

Else

WriteLn ('Las cadenas deben ser del mismo tamaño'); Readln;

End.

Otro Ejemplo:

Program Contar Vocales; Uses CRT; Type Cadena : String[30]; Var Cad : Cadena; TotalLetras : Integer;

Function CuantasLetras (Cad : Cadena) : integer; Var

Longcad, i, TotLetras : integer; Begin

TotLetras := 0;

Longcad := Length (Cad); For i := 1 to Longcad do Begin

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; End; CuantasLetras := TotLetras; End; Begin CLRSCR;

Write ('Ingrese Cadena: '); ReadLn (Cad);

TotalLetras := CuantasLetras (Cad);

Write ('existen ', TotalLetras, ' vocales en ', Cad); Readln; End. Otro Ejemplo: Program SustituirLetras; Uses CRT; Type Cadena : String[30]; Caracter : String[1]; Var Cad : Cadena;

LetraVieja, LetraNueva : Caracter;

Function CambiarLetra (Cad : Cadena; LetraV, LetraN : Caracter) : Cadena; Var Longcad, i : Integer; cadaux : Cadena; Begin cadaux := ' '; For i := 1 to Longcad do Begin

If UpCase (LetraV) = UpCase (Copy (Cad, i, 1)) Then cadaux := cadaux + LetraN

Else

cadaux := cadaux + Copy (Cad, i, 1); End;

CambiarLetra := cadaux; End;

Begin

CLRSCR;

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

Readln; End. Otro Ejemplo: Program IntercalaCarater; Uses CRT; Type Cadena : String[60]; Caracter : String[1]; Var

Cad1, Cadresultante : Cadena; Letra : Caracter;

Intervalo : Integer;

Function Inserta-Caracter (CadA : Cadena; CadB : Caracter; Num : Integer) : Cadena; Var

Longcad, i : Integer; CadR : Cadena; Begin

Longcad := Length (CadA); CadR := ' ';

For i := 1 to Longcad do Begin

If (i mod Num) = 0 Then

CadR := CadR + Copy (CadA, i, 1) + CadB Else

CadR := CadR + Copy (CadA, i, 1) End;

Inserta-Caracter := CadR; End;

Begin

CLRSCR;

Write ('Ingrese Cadena: '); ReadLn (Cad1);

Write ('Ingrese caracter a insertar: '); ReadLn (Letra);

(33)

ReadLn (Intervalo);

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

Readln; End.

Referencias

Documento similar

(ELEGID UNO DE ESTOS PARA HACER EL EJERCICIO 1: “Realizar un balance de objetivos y acciones de un plan local-comarcal, a modo de ejemplo. Link

Volviendo a la jurisprudencia del Tribunal de Justicia, conviene recor- dar que, con el tiempo, este órgano se vio en la necesidad de determinar si los actos de los Estados

y la mujer sentada en la proa del barco. de la mujer con los ojos cerrados. Al comienzo de Limite, todas las imágenes se encadenan a través de fusiones y este encadenamiento refle-

Por una parte, la cadena de valor es un conjunto de actividades interrelacionadas que tiene como principal objetivo el obtener una ventaja competitiva.. Por lo tanto, esta se

Sanz (Universidad Carlos III-IUNE): &#34;El papel de las fuentes de datos en los ranking nacionales de universidades&#34;.. Reuniones científicas 75 Los días 12 y 13 de noviembre

(Banco de España) Mancebo, Pascual (U. de Alicante) Marco, Mariluz (U. de València) Marhuenda, Francisco (U. de Alicante) Marhuenda, Joaquín (U. de Alicante) Marquerie,

Al final del recorrido a través del libro de Bruckner se confirma mi convicción, ade- lantada al inicio, de que puede leerse como una prolongación de la Dialéctica de la

• Suele representar un 15% del valor total económico del proyecto, pero una mala gestión de la misma puede disparar esta cifra hasta hacer disminuir muy significativamente