Embed Size (px)
Citation preview
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
Lista de Constantes;
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>.
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.
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
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;
End.
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;
End.
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:
WriteLn('Area: ', area:0:2);
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;
End.
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;
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
<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.
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');
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');
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
(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.
Otro ejemplo:
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>;
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.
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;
Veamos este ejemplo:
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);
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.
Contamos con dos tipos de parámetros:
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:
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.
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;
End.
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.
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;
End.
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:
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];
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
Longcad : Length (CadA);
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
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);
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);
Write ('Ingrese intervalo: ');
ReadLn (Intervalo);
Cadresultante := Inserta-Caracter (Cad1, Letra, Intervalo);
Write ('La Cadena resultante es: ', Cadresultante);
Readln;
End.
