Escolar Documentos
Profissional Documentos
Cultura Documentos
Palabras reservadas
Para poder programar en cualquier lenguaje es necesario conocer los códigos
mediante los cuales podamos expresar las tareas que queremos realizar. El
Turbo Pascal, como lenguaje de programación poseé su propio código con
Turbo Pascal
ABSOLUTE ASM DESTRUCTOR
IMPLEMENTATION INTERFACE OBJECT
PRIVATE SHR UNIT
VIRTUAL CONSTRUCTOR EXTERNAL
INLINE INTERRUPT SHL
STRING USES XOR
Identificadores
Los identificadores son palabras que representan constantes, variables, tipos de
datos, procedimientos, funciones y algunos otros datos. Existen dos tipos de
identificadores: los predefinidos de Turbo Pascal y los definidos por el
programador.
Algunos de los identificadores predefinidos son: integer, real, byte, sin, ...
file:///D|/Downloads/Books/Transformar/Pascal%20Turbo%20(Manual%20completo)/unidad1p.html (2 de 15) [30/09/2003 12:35:38]
Tutorial básico de Turbo Pascal
Tipos de datos
El manejo de la información en Turbo Pascal se realiza mediante diferentes
clases de datos. En este apartado se tratarán los principales tipos y conforme se
vayan necesitando se explicaran los demás.
Variables y constantes
Los tipos de datos que manejaremos en nuestro programa pueden ser de dos
clases: variables o constantes.
Un ejemplo de una variable es cuando vamos a sumar dos números que serán
introducidos por el usuario del programa, éste puede introducir dos valores
cualesquiera y no sería nada útil restringirlo a dos valores predefinidos, así que
dejamos que use los valores que el necesite sumar.
Las variables y constantes pueden ser de todos los tipos vistos anteriormente:
numéricos tanto enteros como reales, caracteres, cadenas de caracteres, etc.
Comentarios
Es posible introducir comentarios en nuestro programa que sirvan unicamente
para mejorar la comprensión del código fuente.
Todo programa cuenta con algunas partes o módulos los cuales son:
Cabecera
Declaraciones
Programa
Sentencia PROGRAM
La sentencia PROGRAM es la declaración del nombre del programa.
PROGRAM suma_de_dos_numeros ;
Declaración de unidades
Las unidades son módulos independientes del programa que, aunque no son
ejecutables por si mismos, pueden ser utilizados por el programa principal sin
necesidad de reescribir el código que contienen. Para la utilización de estos
"subprogramas" es necesaria su declaración.
Cada unidad que se declara debera estar separada de la siguiente por una coma.
Al final de todas las unidades declaradas se deberá colocar un punto y coma
";".
CONST pi = 3.1415926;
Es posible declarar varias constantes sucesivamente, puede ser una por renglón
o varias en un solo renglón. Cuando se hace ésto, la palabra CONST solo se
pone una sola vez como cabecera y a continuación todas las constantes por
definir. Ejemplo:
CONST
PI = 3.1415926;
Nombre = 'Juan Gutiérrez';
Unidad = 1;
Programa principal
PROGRAM Primera_Prueba;
VAR
Entero : Integer;
CONST
Mensaje = 'Introduce un valor entero: ';
Respuesta = 'El valor es: ';
BEGIN
Write(Mensaje);
{Escribe en pantalla el mensaje definido como constante}
ReadLn(Entero);
{Lee un valor de teclado y lo almacena en la variable Entero}
WriteLn(Respuesta, Entero);
{Escribe en pantalla el contenido de Respuesta y el valor que se ingresó de teclado}
END.
PROGRAM Primera_Prueba;
CONST
Mensaje = 'Introduce un valor entero: ';
Respuesta = 'El valor es: ';
VAR
Entero : Integer;
BEGIN
Write(Mensaje);
{Escribe en pantalla el mensaje definido como constante}
ReadLn(Entero);
{Lee un valor de teclado y lo almacena en la variable Entero}
WriteLn(Respuesta, Entero);
{Escribe en pantalla el contenido de Respuesta y el valor que se ingresó de teclado}
END.
Compilación al disco
Para poder ejecutar un programa sin necesidad de llamar al entorno integrado
de desarrollo de Turbo Pascal es necesario compilar el programa al disco.
Para hacer esto es necesario activar la opción Destination a Disk, esto se hace
entrando al menú Compile, se selecciona la opción Destination y se presiona
[Enter], de esta forma se cambia el destino de compilación de memoria a disco
Asignación o igualación
La operación de asignación es una de las más utilizadas en Turbo Pascal ya que
nos permite darle un valor determinado a las variables que declaramos en el
programa o lo que es lo mismo, igualarla a algún valor determinado.
El símbolo utilizado para la operación es los dos puntos seguidos por un signo
de igual := , a la izquierda de dicho símbolo se coloca el identificador al que se
le asignará un nuevo valor y a la derecha se colocará un identificador o algún
valor directo que se almacenará en el primer identificador. Ejemplo:
Write (indentificadores);
WriteLn (indentificadores);
Write (Nombre);
Write (ApellidoP);
Write (ApellidoM);
Si en lugar de utilizar la instrucción Write hacemos uso de WriteLn con la
misma sintaxis del ejemplo anterior:
WriteLn (Nombre);
WriteLn (ApellidoP);
WriteLn (ApellidoM);
Rodrigo
González
García
De este ejemplo es posible concluir que la diferencia entre las instrucciones
Write y WriteLn es que esta última imprime el contenido de los identificadores
y cambia el cursor al siguiente renglón de la pantalla, y la primera solo escribe
el contenido y deja el cursor al final del dato escrito.
Las instrucciones estandar de Turbo Pascal para obtener datos desde el teclado
son Read y ReadLn. La sintaxis de estas instrucciones es muy parecida a la de
Write y WriteLn:
Read (Identificador);
Tipos de datos
Un programa debe ser capaz de manejar diferentes tipo de datos, como pueden
ser números enteros, reales, caracteres, cadenas de caracteres, etc. Para lograr
el manejo de toda esta información Turbo Pascal proveé diferentes tipos de
datos para los identificadores que se utilizarán. Algunos de los más importantes
se citan en seguida:
Tipos enteros
En esta categoría Turbo Pascal cuenta con 5 tipos diferentes, cada uno abarca
un rango específico de valores y utilizan una diferente cantidad de memoria
dependiendo de ese rango. Naturalmente el trabajar con rangos menores nos
ofrece una mayor velocidad y menor espacio en memoria, pero si se utilizan
enteros largos se cuenta con mayor presición. Los tipos de enteros en Turbo
Pascal son:
Cantidad := $10;
Tipos reales
Los números reales son aquellos que cuentan con una parte decimal. En Turbo
Pascal contamos con varios tipos de datos reales, pero no se puede utilizar, mas
que el tipo real, en máquinas que no cuenten con un coprocesador matemático.
Los tipos de datos reales son:
Los números reales deben llevar por fuerza al menos un dígito de cada lado del
punto decimal así sea éste un cero. Como ejemplo, el número 5 debe
representarse como: 5.0, el .5 como 0.5 , etc.
Tipos caracter
Los caracteres son cada uno de los símbolos que forman el código ASCII, el
tipo estándar de Pascal para estos datos es Char. Los caracteres se especifican
entre apostrofes:
El tipo Char es un tipo ordinal de Pascal, ésto quiere decir que sus elementos
válidos siguen una secuencia ordenada de valores individuales. La secuencia de
caracteres para este tipo corresponden al número del código ASCII, del 0 al
255.
Tipo cadena
Las cadenas son secuencias de caracteres o arreglos que tienen una longitud
maxima de 255 caracteres. Se definen entre apostrofes. El tipo de Pascal para
las cadenas es String.
PROGRAM Cadena;
VAR
Nombre : String;
BEGIN
Nombre := 'Ernesto Chávez';
WriteLn (Nombre);
END.
Este programa guarda la cadena 'Ernesto Chávez' en la variable definida como
tipo string, y la visualiza en la pantalla por medio de la instrucción WriteLn.
El tamaño por defecto para un tipo string es de 255 caracteres, pero es posible
definir uno mas pequeño utilizando el siguiente formato:
Variable : String[Tamaño];
Donde Variable es la variable a definir y Tamaño es el número maximo de
caracteres que podrá contener esa variable (naturalmente mayor a 0 y menor a
256).
PROGRAM Cadena01;
VAR
Nombre : String[30];
{Permite un máximo de 30 caracteres en la variable}
BEGIN
Nombre := 'Ernesto Chávez';
WriteLn (Nombre[5]);
{Visualiza el 5to caracter de la cadena}
END.
Tipos lógicos
Este tipo de datos tienen la peculiaridad de que solo pueden tomar dos tipos de
datos: verdadero o falso, el verdadero puede ser representado por su nombre en
inglés: True y el falso por False; también se representan por 1 y por 0
file:///D|/Downloads/Books/Transformar/Pascal%20Turbo%20(Manual%20completo)/unidad1p.html (14 de 15) [30/09/2003 12:35:38]
Tutorial básico de Turbo Pascal
respectivamente.
Operaciones Aritméticas
Operaciones básicas
Operadores DIV y MOD (Enteros)
Prioridad de operadores
Constantes variables
Uso de las constantes variables
Constantes expresiones
Uso de las expresiones como constantes
Operaciones básicas
Las operaciones básicas en Turbo Pascal están formadas por dos partes: el
operador y los operandos.
Operador Operación
+ Suma
- Resta
* Multiplicación
/ División
El tipo de datos que pascal regresa como resultado de una operación dependerá
del tipo de datos usados como operandos. Por ejemplo, la suma de dos enteros
da como resultado otro entero, y la suma de dos números reales da como
resultado otro número real.
número real, así que para dividir dos enteros, y obtener el resultado como
entero, Turbo Pascal ofrece el operador DIV, el cual da el resultado entero de
una división entre enteros, y el operador MOD que regresa el residuo de una
división de enteros.
Su sintaxis es:
PROGRAM Operaciones_Básicas;
VAR
Suma, Resta, Multiplicacion, Division : Real;
Cociente_Entero, Residuo_Entero : Integer;
BEGIN
Suma := 12 + 8;
Resta := 12 - 8;
Multiplicacion := 12 * 8;
Division := 12/8;
Cociente_Entero := 12 DIV 8;
Residuo_Entero := 12 MOD 8;
WriteLn ('La suma de 12 + 8 es igual a: ',Suma);
WriteLn ('La resta de 12 - 8 es igual a: ',Resta);
WriteLn ('La multiplicación de 12 * 8 es igual a: ',Multiplicacion);
WriteLn ('La división de 12 / 8 es igual a: ',Division);
WriteLn ('La división entera de 12 / 8 es igual a: ',Cociente_Entero);
WriteLn ('El residuo de la división entera de 12 / 8 es: ',Residuo_Entero);
END.
Prioridad de operadores
Cuando se utilizan en alguna expresión mas de un operador, éstos se evaluan
conforme a una prioridad establecida por Turbo Pascal. Es necesario conocer el
orden de evaluación para evitar errores en nuestros programas.
PROGRAM Operadores;
VAR
Resultado_Uno, Resultado_Dos : Real;
BEGIN
Resultado_Uno := 3 + 5 * 7;
Resultado_Dos := (3 + 5) * 7;
WriteLn ('El resultado de la operación 3 + 5 * 7 es: ',Resultado_Uno);
WriteLn ('El resultado de la operación (3 + 5) * 7 es: ',Resultado_Dos);
END.
Ejemplo:
PROGRAM Constantes_Variables;
CONST
Valor_Inicializado : Integer = 23;
Texto_Inicializado : String = 'Buenos Dias!';
VAR
Texto : String;
Entero : Integer;
BEGIN
WriteLn ('Cadena inicializada: ',Texto_Inicializado);
WriteLn ('Cadena sin inicializar: ',Texto);
WriteLn ('Entero inicializado: ',Valor_Inicializado);
WriteLn ('Entero sin inicializar: ',Entero);
END.
CONST
Columnas = 80;
Filas = 24;
Total_de_espacios = Columnas * Filas;
Solo es posible utilizar constantes en las expresiones de este tipo, si se usa
alguna variable ocurrirá un error al momento de compilar el programa.
Sentencias compuestas
Sentencias compuestas
Sentencias repetitivas
Ciclos FOR
Ciclos WHILE
Ciclos REPEAT-UNTIL
Bifurcaciones condicionales
IF...THEN...ELSE
IF anidados
CASE
Bifurcaciones incondicionales
GOTO
HALT
Sentencias compuestas
Las sentencias compuestas son grupos de sentencias, separadas cada una por un
punto y coma ";" que son tratadas como una sola sentencia.
PROGRAM Prueba;
BEGIN
WriteLn('Primera linea de una sentencia compuesta');
WriteLn('Segunda linea de una sentencia compuesta');
WriteLn('Tercera linea de una sentencia compuesta');
END.
El punto y coma que se encuentra antes de la palabra reservada END puede ser
Ciclos FOR
El ciclo FOR repite una sentencia un determinado número de veces que se
indica al momento de llamar al ciclo.
Lo que hace FOR es que incrementa una variable en uno desde un valor inicial
hasta un valor final ejecutando en cada incremento la sentencia que se quiere
repetir. Su sintaxis es:
PROGRAM Ciclo_FOR;
VAR
Numero : Integer;
BEGIN
FOR Numero := 1 to 50 DO
WriteLn(Numero);
END.
Una de las limitaciones de los ciclos FOR es que una vez iniciado el ciclo se
ejecutará el número de veces predefinido sin posibilidad de agregar o eliminar
ciclos.
Es posible hacer que un ciclo cuente hacia atrás, es decir que la variable en
PROGRAM Ciclo_FOR_2;
VAR
Numero : Integer;
BEGIN
FOR Numero := 50 DOWNTO 1 DO
WriteLn(Numero);
END.
Ciclos WHILE
Los ciclos WHILE ofrecen la ventaja de que la ejecución se realiza mientras se
cumpla una condición, por lo tanto es posible controlar el número de
repeticiones una vez iniciado el ciclo. Su sintaxis es:
Un programa que escriba los números del 1 al 50, utilizando el ciclo WHILE se
vería como sigue:
PROGRAM Ciclo_WHILE;
VAR
Numero : Integer;
BEGIN
Numero := 1;
WHILE Numero <= 50 DO
BEGIN
WriteLn (Numero);
Numero := Numero +1;
END;
END.
Al final del programa la variable Numero guardará el valor 51, que fué el valor
file:///D|/Downloads/Books/Transformar/Pascal%20Turbo%20(Manual%20completo)/unidad3p.html (3 de 7) [30/09/2003 12:36:51]
Tutorial básico de Turbo Pascal
Ciclos REPEAT-UNTIL
Este tipo de ciclos es muy parecido a los ciclos WHILE, la diferencia entre
ambos es que en WHILE la condición se evalúa al principio del ciclo, en
cambio en REPEAT-UNTIL se evalúa al final, lo que significa que en un ciclo
REPEAT-UNTIL la sentencia se ejecutará por lo menos una vez, cosa que
puede no ocurrir en el ciclo WHILE. Ejemplo:
PROGRAM Ciclo_RepeatUntil;
VAR
Numero : Integer;
BEGIN
Numero := 1;
REPEAT
WriteLn (Numero);
Numero := Numero + 1;
UNTIL Numero = 50;
END.
Para lograr este control se cuenta con las estructuras de control que, en Turbo
Pascal, son las siguientes:
Sentencia IF...THEN...ELSE
Esta expresión es utilizada para ejecutar una sentencia en el caso que una
condición establecida sea verdadera, de lo contrario se podra ejecutar una
sentencia distinta. Su sintaxis es:
PROGRAM IF_THEN_ELSE;
VAR
Contador : Integer;
BEGIN
FOR contador := 1 to 50 DO
BEGIN
IF contador > 10 THEN WriteLn(Contador) ELSE WriteLn('*');
END;
END.
Sentencias IF anidadas
Es posible utilizar en una expresión del tipo IF..THEN..ELSE una sentencia
compuesta como la sentencia a ejecutarse en caso de que la condición sea
verdadera, así como en la sentencia posterior a un ELSE, de esta forma
podemos utilizar otra sentencia IF..THEN..ELSE dentro de la anterior, para de
esta forma evaluar varias condiciones una dentro de otra. Ejemplo:
Selecciones CASE
Esta forma de control se utiliza cuando se va a evaluar una expresión que puede
contener varios datos diferentes y en cada dato deberá realizar una acción
especial. Por ejemplo, si se crea un menú con diferentes opciones se realizará
un determinado proceso para cada acción, aunque la selección por parte del
usuario se haga desde el mismo lugar.
PROGRAM Case;
VAR
Numero : Integer;
BEGIN
WriteLn('Introduzca un número entero del 1 al 5: ');
ReadLn(Numero);
CASE Numero OF
1 : WriteLn('El número fué 1');
2 : WriteLn('El número fué 2');
3 : WriteLn('El número fué 3');
4 : WriteLn('El número fué 4');
5 : WriteLn('El número fué 5');
ELSE WriteLn('El número no estaba en el rango indicado');
END.
GOTO
La sentencia GOTO es una sentencia utilizada para alterar el flujo del
programa, es decir, para ir a ejecutar una sentencia en un lugar diferente del
programa y no la linea siguiente.
Para utilizar este tipo de salto es necesario declarar etiquetas, que no son otra
cosa que el identificador que marcará el lugar a donde se dirigirá el flujo del
programa al momento de usar el GOTO. La declaración de etiquetas se hace
GOTO etiqueta;
Ejemplo:
PROGRAM Uso_del_GOTO;
LABEL
Etiqueta;
BEGIN
WriteLn('Esta linea si se escribirá');
GOTO Etiqueta;
WriteLn('Esta linea no se escribirá');
Etiqueta:
WriteLn('Se efectuó el brinco');
END.
HALT
La instrucción HALT provoca la terminación inmediata de un programa, sin
importar las siguientes instrucciones. Normalmente se utiliza en casos de error,
se despliega un mensaje y se termina el programa. Ejemplo:
PROGRAM Uso_de_HALT;
BEGIN
WriteLn('Primera linea del programa');
WriteLn('Terminará la ejecución del programa');
HALT
WriteLn('');
END.
Procedimientos
Definición
Creación
Uso de los procedimientos
Variables locales y globales
Paso de información entre procedimientos
Parámetros
Funciones
Definición
Uso de las funciones
Procedimientos predefinidos en Turbo Pascal
HALT y EXIT
INC y DEC (incrementar y decrementar)
Definición de procedimiento
Un procedimiento es un grupo de sentencias que realizan una tarea concreta.
En lugar de reescribir el código completo de esa tarea cada vez que se necesite,
unicamente se hace una referencia al procedimiento.
Una vez creado un procedimiento actuará como una instrucción más de Turbo
Pascal, y para ejecutarlo unicamente teclearemos el nombre de dicho
procedimiento.
PROGRAM Procedimientos;
PROCEDURE Titulo;
BEGIN
WriteLn ('Programa de Turbo Pascal');
END;
BEGIN
WriteLn ('Programa ejemplo del uso de procedimientos');
Titulo;
{Llama al procedimiento}
WriteLn;
Titulo;
{Vuelve a llamar al procedimiento}
END;
PROGRAM Variables;
VAR
Hola : String;
PROCEDURE prueba;
VAR
Adios : String;
BEGIN
{En esta sección si es posible usar la variable Hola}
Adios := 'Adios, que les vaya bien';
WriteLn (Adios);
END;
BEGIN
{En esta sección no se reconoce a la variable Adios}
Hola := 'Hola, bienvenidos al programa';
WriteLn (Hola);
WriteLn (Adios);
{Al compilar el programa se generará un error ya que la variable Adios es inexistente en esta
sección, para eliminar el problema quites esta linea}
prueba;
END.
Es posible darle el mismo nombre a una variable local y a una global en el
mismo programa, pero entonces el procedimiento no podrá utilizar la variable
global ya que le da preferencia a las locales sobre las globales. Por ejemplo:
PROGRAM Variables_2;
VAR
Saludo : String;
PROCEDURE Mensaje;
VAR
Saludo : String;
BEGIN
Saludo := 'Este mensaje solo es válido para el procedimiento "Mensaje"';
WriteLn('Saludo');
END;
BEGIN
Saludo := 'Primer saludo (Global)';
WriteLn (Saludo);
Mensaje;
WriteLn (Saludo); {Se escribirá el mensaje "Primer saludo"}
END.
Parámetros
Para poder pasar información entre el programa principal y procedimientos, o
entre los mismos procedimientos usamos los parámetros, que son los canales de
comunicación de datos.
La lista de parámetros esta compuesta de los nombres de los mismos y del tipo
de datos que representan, los del mismo tipo se separan con comas "," y cada
tipo diferente se separa con punto y coma ";". Ejemplo:
PROGRAM Parametros;
VAR
Saludo : String;
BEGIN
Saludo := 'Bienvenidos al programa';
Imprime_5 (Saludo);
{llama al procedimiento Imprime_5, usando como}
{parámetro la variable Saludo }
Imprime_5 ('Fin');
{Utiliza la cadena "fin" como parámetro }
END.
Es válido crear un procedimiento que llame a otro procedimiento siempre y
cuando el procedimiento llamado haya sido declarado antes del que lo usará.
PROGRAM Funciones;
VAR
X, Y, Z : Real;
BEGIN
X := 5.89;
Y := 9.23;
Z := Promedio (X, Y);
{Iguala Z al valor devuelto por la función Promedio}
WriteLn('El promedio de ',X,' y ',Y,' es: ',Z);
END.
Procedimieto HALT
El procedimiento HALT ya se habia revisado anteriormente, pero se tomó
como una instrucción, siendo que es realmente un procedimiento predefinido
de Turbo Pascal que nos permite terminar nuestro programa en cualquier punto
del mismo.
Variable := Variable + 1;
o telcear:
Inc(Variable);
DEC (Variable);
Truncamiento y redondeo
La función Round (número) redondea un número real al entero más cercano y
devuelve el resultado como un número real.
PROGRAM Redondeo;
VAR
Entero : Integer;
ValorReal1, ValorReal2 : Real;
BEGIN
ValorReal1 := 123.435;
ValorReal2 := Round(ValorReal1);
Entero := Trunc (ValorReal1);
WriteLn('El resultado de la función Round sobre el valor');
WriteLn(ValorReal1, ' es: ','ValorReal2, ' (Número real)');
WriteLn('El resultado de la función Trunc sobre el valor');
WriteLn(ValorReal1, ' es: ', Entero, ' (Número entero)');
END.
Sqrt regresa la raíz cuadrada del valor dado como parámetro, el resultado
PROGRAM Exponentes;
VAR
Dato, Cuadrado : Integer;
Raiz : Real;
BEGIN
Dato := 45;
Cuadrado := Sqr(Dato);
Raiz := Sqrt(Dato);
WriteLn(' El cuadrado de ',Dato, ' es: ',Cuadrado);
WriteLn('La raíz cuadrada de ',Dato,' es: ',Raiz);
END.
Es posible crear una función con base en estas dos para calcular el resultado de
un número x elevado a una potencia n, la cual nos quedaría así:
FUNCTION Potencia(x,n:Real):Real;
BEGIN
Potencia := Exp(n *Ln(x))
END;
PROGRAM Potenciacion;
FUNCTION Potencia(x, n : Real) : Real;
BEGIN
Potencia := Exp(n * Ln(x))
END;
BEGIN
WriteLn('El resultado de 5 elevado a 3 es: ',Potencia(5,3));
END.
Funciones aritméticas
Abs regresa el valor absluto del identificador que se le pase como parámetro.
file:///D|/Downloads/Books/Transformar/Pascal%20Turbo%20(Manual%20completo)/unidad5p.html (2 de 4) [30/09/2003 12:37:11]
Tutorial básico de Turbo Pascal
La función Frac regresa la parte decimal de un valor real, también como valor
real.
Funciones trigonométricas
Las funciones trigonometricas definidas en Turbo Pascal son: Sin(valor),
Cos(valor) y Arctan(valor), todas las demas pueden definirse desde estas:
PROGRAM Nums_Aleatorios;
VAR
x : Integer;
BEGIN
Randomize
WriteLn('Lista de números aleatorios');
For x := 1 to 20 do
WriteLn(Random);
END.
VAR
Mensaje : String[120]; {Longitud maxima = 120 caracteres}
Comparación de cadenas
La comparación de cadenas es una operación muy común en Turbo 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 caracter
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.
PROGRAM Caracter;
VAR
Calle : String;
Letra : String;
BEGIN
Calle := 'Hidalgo';
WriteLn(Calle[2]); {Visualiza el segundo caracter de Calle}
Letra := Calle[1]; {Guarda en Letra el primer caracter de Calle}
WriteLn(Caracter) END.
Su sintaxis es:
Length (cadena);
PROGRAM Funcion_Length;
VAR
Cadena : String;
BEGIN
Cadena := 'Prueba de longitud';
WriteLn ('Longitud de la cadena: ', Length (Cadena));
END.
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:
Se imprimirá en la pantalla: 'Buenos dias'. (Notese que este ejemplo es solo una
sección del programa, para ejecutarlo es necesario completar la estructura).
Función 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.
Pos
Laa 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:
Ejemplo:
Copy
La función copy regresa una subcadena de una variable o constante dada como
parámetro. Su sintaxis es:
Ejemplo:
Insert
El procedimiento Insert sirve para insertar una cadena dentro de otra en alguna
posición determinada. Sintaxis:
Delete
Este procedimiento elimina un determinado número de caracteres de una
cadena. Su sintaxis es:
UpCase
La función UpCase regresa la letra mayuscula correspondiente al caracter dado
como parámetro. 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.
Str
El procedimiento Str obtiene una cadena a partir de un valor numérico. Su
sintaxis es:
Str(Valor, Cadena)
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:
Concepto de unidad
Concepto de unidad
La declaración USES
Creación de unidades
Estructura de las unidades
Creación de una unidad
Compilación de la unidad
Utilización de las unidades
Uso de las unidades
Concepto de unidad
Las unidades son grupos de funciones o procedimientos compilados que
pueden ser llamados y utilizados desde cualquier programa en Turbo Pascal sin
necesidad de escribirlos de nuevo.
Las unidades no son ejecutables por si solas, dependen del programa que las
llama para poder realizar su función.
Turbo Pascal incorpora algunas unidades que contienen una gran cantidad de
rutinas integradas, pero para hacer uso de ellas es necesario primero declarar el
uso de tales unidades.
La declaración USES
Para declarar una unidad, o lo que es lo mismo, dejarla lista para ser utilizada,
se utiliza la palabra reservada USES que debe ir inmediatamente despues de la
sentencia PROGRAM, despues se escriben los nombres de las unidades que se
utilizarán.
Crt
Dos
Graph
Overlay
Printer
System
Declaración
Es obligatoria, provee el nombre de la unidad que se creará. Su suntaxis es:
UNIT nombre_de_la_unidad;
Ejemplo:
UNIT prueba;
Interfaz
Esta sección se declara con la palabra INTERFACE, en esta sección se
encuentran las declaraciones de todos los elementos que pueden ser utilizados
por el programa que llama a la unidad, por ejemplo otras unidades, variables,
constantes, procedimientos y funciones. En esta sección no se incluyen los
códigos de los procedimientos ni funciones, unicamente su declaración.
Ejemplo:
INTERFACE
USES Crt, Dos;
VAR
Numero : Integer;
CONST
Columnas = 10;
PROCEDURE Colocar(Cad1 : String; X, Y : Integer);
Implementación
La sección de implementación es exclusiva para la unidad que se está creando,
IMPLEMENTATION
USES Crt;
PROCEDURE Colocar(Cad1 : String; X, Y : Integer);
BEGIN
GotoXY(X,Y);
Write(Cad1);
END;
Inicialización
Esta sección se utiliza para inicializar los valores de las variables, no es
indispensable y por lo mismo no siempre se incluye. Su sintaxis es parecida a
la del cuerpo principal de un programa, se inicia con BEGIN y termina con un
END.
UNIT Prueba;
INTERFACE
PROCEDURE Centrar(Cad1 : String; renglon : Integer);
IMPLEMENTATION
USES Crt;
VAR C : Integer;
BEGIN
END.
Compilación de la unidad
Para compilar una unidad y dejarla lista para su utilización en programas
posteriores se utiliza la opción Compile en el menú del mismo nombre.
La secuencia de teclas [ALT] + [F9] también compilan la unidad así como los
programas dependiendo del caso.
Es posible visualizar estos archivos con la orden TYPE del sistema operativo
DOS y se pueden editar con cualquier editor de textos.
Declaración de un archivo
Para declarar un archivo primero se declara una variable tipo text de la
siguiente forma:
VAR
VarArchivo : Text;
Abrir archivos
Exsiten tres formas de abrir un archivo:
La instrucción Read lee uno o varios datos del archivo abierto y deja el puntero
en el mismo renglón en el cual leyó los datos, en cambio ReadLn lee los datos
y mueve el puntero al siguiente renglón.
EOF (VaribleArchivo);
Cerrar archivos
Para asegurar que toda la información se grabe en el disco correctamente es
necesario cerrar el archivo antes de que se termine la ejecución del programa,
de lo contrario se corre el riego de que la última información que se haya
accesado no se grabe en su totalidad.
Close (VaribleArchivo);
Función Eoln
La función Eoln sirve para verificar si el puntero ha llegado al final de la linea.
Regresa el valor verdadero si se encuentra al final. Comunmente se utiliza en
las lecturas caracter por caracter.
PROGRAM Archivo;
VAR
Texto : TEXT;
BEGIN
Assign (Texto, 'PRUEBA.DAT');
Append(Texto);
WriteLn(Texto, 'Agregando una linea al archivo PRUEBA.DAT');
Close (Texto)
END.
Los archivos de acceso directo son también llamados archivos con tipos o
tipeados.
Este tipo de archivos no pueden ser visualizados con la instrucción type del
sistema operativo debido al formato utilizado para guardarlos.
Declaración de un archivo
Para declarar un archivo de acceso directo se realiza con las palabras
reservadas FILE OF, su sintaxis es la siguiente:
PROGRAM Archivo_Tipeado;
VAR
Archivo : FILE OF Integer;
BEGIN
END.
Los registros del tipo record deben ser declarados antes de las variables en una
sección llamada TYPE con el siguiente formato:
TYPE
Nombre_Reg = RECORD
Campo_del_registro_1 : Tipo;
Campo_del_registro_2 : Tipo;
...
Campo_del_registro_n : Tipo;
END;
TYPE
Datos = RECORD
Nombre : String[40];
Domicilio : String[60];
Edad : Integer;
EdoCivil : String[10];
END;
El siguiente paso es declarar un archivo del tipo Datos así como una variable
del mismo tipo de los que se utilizarán en el archivo:
VAR
Archivo : FILE OF Datos;
Persona : Datos;
Asignación de un archivo
Aún cuando se tenga declarado el archivo no es posible grabar nada en él si no
se le asigna un nombre real para guardarlo en el disco. El proceso de dicha
asignación es el mismo que para los archivos de texto:
Nombre.txt puede ser una constante, una variable o estar escrita directamente
en el programa. Naturalmente debe cumplir con todas las reglas para nombrar
un archivo.
Abrir archivos
Una vez declarado un archivo ya es posible abrirlo. En caso de querer abrir un
file:///D|/Downloads/Books/Transformar/Pascal%20Turbo%20(Manual%20completo)/unidad8p.html (7 de 9) [30/09/2003 12:37:50]
Tutorial básico de Turbo Pascal
FilePos (VariableArchivo)
Para moverse al final del archivo para agregar un nuevo registro se utiliza este
file:///D|/Downloads/Books/Transformar/Pascal%20Turbo%20(Manual%20completo)/unidad8p.html (8 de 9) [30/09/2003 12:37:50]
Tutorial básico de Turbo Pascal
Para estar seguros de que se leera el registro que se desea se debe emplear el
procedimiento seek antes de cualquier procedimiento de lectura o escritura.
Cerrar un archivo
Para cerrar los archivos abiertos se procede igual que en uno de acceso
secuencial, utilizando el procedimiento close:
Close (VariableArchivo);
Constantes predefinidas
Modo de pantalla
Colores
Variables predefinidas
CheckBreak
DirectVideo
LastMode
TextAttr
WindMin
WindMax
Procedimientos predefinidos
ClrEol
ClrScr
Delay
DelLine
GotoXY
HighVideo
InsLine
LowVideo
NormVideo
NoSound
Sound
TextBackground
TextColor
TextMode
Window
Funciones predefinidas
KeyPressed
ReadKey
WhereX
WhereY
Modo de Pantalla
Las constantes definidas de Turbo Pascal para indicar el modo de pantalla que
se utilizará son:
Colores
Las constantes definidas para los colores son:
Parpadeo
Blink 128
CheckBreak
Tipo : boolean.
DirectVideo
Tipo : boolean.
LastMode
Tipo : Word
TextAttr
Tipo : Byte
WindMin
file:///D|/Downloads/Books/Transformar/Pascal%20Turbo%20(Manual%20completo)/unidad9p.html (3 de 10) [30/09/2003 12:38:00]
Tutorial básico de Turbo Pascal
WindMax
Esta variable contiene las coordenadas de la esquina inferior derecha de la
ventana de texto activa definida por el procedimiento Window.
ClrEol
Sintaxis:
ClrEol;
PROGRAM Proc_ClrEol;
USES Crt;
VAR x,y : Integer;
BEGIN
FOR x := 1 TO 24 DO
FOR y := 1 TO 80 DO
Write('#');
GotoXY(15,15);
ClrEol;
END.
ClrScr
Sintaxis:
ClrScr;
PROGRAM LimpiarPantalla;
USES Crt;
VAR x,y : Integer;
Prb : String;
BEGIN
FOR x := 1 TO 24 DO
FOR y := 1 TO 80 DO
Write('#');
WriteLn('Presione [ENTER] para borrar la pantalla');
ReadLn(Prb);
ClrScr;
WriteLn('Se borró la pantalla');
END.
Delay
Sintaxis:
Delay(Tmp : Word);
PROGRAM Retardo;
USES Crt;
BEGIN
WriteLn('Inicia retardo de aproximadamente 5 segundos');
Delay(5000);
WriteLn('Fin del retardo');
END.
DelLine
Sintaxis:
DelLine;
Borra la linea donde se encuentra el cursor y las lineas inferiores suben una
posición. Ejemplo
PROGRAM BorrarLinea;
USES Crt;
VAR x : Integer;
prb : String;
BEGIN
ClrScr;
For x := 1 to 20 DO
WriteLn('Linea número: ', x);
WriteLn('Presione [ENTER] para borrar la linea 6');
GotoXY(0,6);
DelLine;
WriteLn('Linea 6 eliminada');
END.
GotoXY
Sintaxis:
GotoXY(x, y : Byte);
PROGRAM Posición;
USES Crt;
BEGIN
GotoXY(10,10);
Write('*');
GotoXY(20,20);
Write('*');
END.
HighVideo
Sintaxis:
file:///D|/Downloads/Books/Transformar/Pascal%20Turbo%20(Manual%20completo)/unidad9p.html (6 de 10) [30/09/2003 12:38:00]
Tutorial básico de Turbo Pascal
HighVideo;
InsLine
Sintaxis:
InsLine
LowVideo
Sintaxis:
LowVideo
NormVideo
Sintaxis:
NormVideo;
NoSound
Sintaxis:
NoSound;
Sound
Sintaxis:
TextBackground
Sintaxis:
Se utiliza para seleccionar el color del fondo de la pantalla. Los valores que
puede utilizar son del 0 al 7, también es posible utilizar las constantes
predefinidas para los colores.
TextColor
Sintaxis:
TextMode
Sintaxis:
Define el modo de video, ésto es, el número de filas y columnas que se podrán
mostrar en pantalla, también si se mostrarán en blanco y negro o en color.
Window
Sintaxis:
KeyPressed
Tipo: Boolean
ReadKey
Tipo: Char
Esta función lee un caracter del teclado, se utiliza mucho para leer teclas de
WhereX
Tipo: Byte
WhereY
Tipo: Byte