MANUAL DE INTRODUCCION A LA PROGRAMACION BASICA

TURBO PASCAL

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 palabras de uso exclusivo para
ciertas funciones, a estas palabras les llamaremos palabras reservadas de Turbo Pascal.

Las palabras reservadas de Turbo Pascal (versiones 6.0 o mayores) son:

Pascal Estandar y Turbo Pascal 6.0

AND ARRAY BEGIN CASE
CONST DIV DO DOWNTO
ELSE END FILE FOR
FORWARD FUNCTION GOTO IF
IN LABEL MOD NIL
NOT OF OR PACKED
PROCEDURE PROGRAM RECORD REPEAT
SET THEN TO TYPE
UNTIL VAR WHILE WITH

Turbo Pascal
ABSOLUTE ASM DESTRUCTOR
IMPLEMENTATION INTERFACE OBJECT
PRIVATE SHR UNIT
VIRTUAL CONSTRUCTOR EXTERNAL
INLINE INTERRUPT SHL
STRING USES XOR

Estas palabras no pueden ser usadas como identificadores (siguiente tópico) ya que cada
una de ellas tiene una función definida en Turbo Pascal.

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

Los identificadores definidos por el programador son los elementos del lenguaje tales
como variables, procedimientos, funciones, etc.

Un identificador es una secuencia de 1 a 127 caracteres, que inicia con una letra, no tienen
espacios ni símbolos: &, !, *, etc. y no es alguna palabra reservada.

Para el Turbo Pascal no existen diferencias entre mayúsculas y minúsculas, así que a un
identificador denominado "valor" se le puede referir como "VALOR" o "VaLoR".

Todo identificador en Pascal debe ser definido previamente a su utilización.

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.

Integer Números enteros sin parte decimal.

Char Caracteres del código ASCII
Boolean Pueden contener los valores de falso o verdadero
Real Números que pueden incluir una parte decimal
String En una secuencia de caracteres que se trata como un solo dato.

 Integer: Es un número entero con signo, que puede valer desde -32768 hasta 32767.
Ocupa 2 bytes de memoria.

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

 Char: Representa a un carácter (letra, número o símbolo). Ocupa 1 byte.

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

 Boolean: Es una variable lógica, que puede valer TRUE (verdadero) o FALSE (falso), y
se usa para comprobar condiciones.

Variables y constantes
Los tipos de datos que manejaremos en nuestro programa pueden ser de dos clases:
variables o constantes.

Como su nombre lo indica las variables pueden cambiar a lo largo de la ejecución de un

programa, en cambio las constantes serán valores fijos durante todo el proceso.

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.

Ahora, si nuestro programa de operaciones matemáticas va a utilizar el valor de PI para

algunos cálculos podemos definir un identificador PI con el valor de 3.1415926 constante,
de tal forma que PI no pueda cambiar de valor, ahora en lugar de escribir todo el número
cada vez que se necesite en nuestro programa, solo tenemos que escribir PI.

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 únicamente para
mejorar la comprensión del código fuente.

Un comentario no es tomado en cuenta al momento de la compilación del programa y es

de enorme importancia al momento de crearlo, modificarlo o mantenerlo.

Existen dos formas de colocar comentarios en un programa de Turbo Pascal, entre llaves:
{Comentario} o entre parentesis y asteriscos: (*Comentario*).

Estructura de los programas

El lenguaje utilizado en Turbo Pascal es estructurado, lo que significa que cada programa
requiere una forma específica de escritura para que sea entendido por el compilador.

Todo programa cuenta con algunas partes o módulos los cuales son:

Cabecera
Declaraciones
Programa

La cabecera del programa unicamente lleva el nombre del programa. En la sección de

declaraciones se le indica al compilador todos los identificadores y unidades que se
utilizarán durante la ejecución del programa. En la sección del programa se escribe el
código de instrucciones que se llevarán a cabo.

Sentencia PROGRAM
La sentencia PROGRAM es la declaración del nombre del programa.

Consta de tres partes: la palabra reservada PROGRAM, a continuación un identificador

utilizado como el nombre del programa y al final un punto y coma ";". Por ejemplo:

PROGRAM suma_de_dos_numeros ;

Esta declaración es siempre la primer linea en cualquier programa de Turbo Pascal.

Declaración de unidades
Las unidades son módulos independientes del programa que, aunque no son ejecutables
por si mismos, pueden ser utilizados por el programa principal sin necesidad de reescribir
el código que contienen. Para la utilización de estos "subprogramas" es necesaria su
declaración.

La palabra reservada USES cumple el propósito de declarar las unidades en el formato

siguiente:

USES crt, dos;

Esta línea declara y habilita para su uso a la unidad crt y a la unidad dos

Cada unidad que se declara debera estar separada de la siguiente por una coma. Al final
de todas las unidades declaradas se deberá colocar un punto y coma ";".

Declaración de constantes y variables

Para declarar las constantes se utiliza la palabra reservada CONST seguida de un
identificador al que se le dará un valor determinado, un signo de igual "=", el valor que
recibirá el identificador y al final un punto y coma ";". Ejemplo:
CONST pi = 3.1415926;

De esta forma el identificador pi recibirá el valor de 3.1415926 y no será posible

cambiarlo en el transcurso del programa.

Es posible declarar varias constantes sucesivamente, puede ser una por renglón o varias en
un solo renglón. Cuando se hace esto, la palabra CONST solo se pone una sola vez como
cabecera y a continuación todas las constantes por definir. Ejemplo:

CONST
PI = 3.1415926;
Nombre = 'Juan Gutiérrez';
Unidad = 1;

Otra forma de escribir lo mismo es así:

CONST PI = 3.1415926; Nombre = 'Juan Gutiérrez'; Unidad = 1;

Pero por cuestiones de legibilidad es preferible la primera opción.

La declaración de variables se lleva a cabo de la misma forma, solo que en lugar de la

palabra CONS utilizamos la palabra VAR, y en lugar de "= valor;", utilizamos : tipo ,
sustituyendo "tipo" por alguna clase válida de datos en Turbo Pascal. Ejemplo:

VAR Num_entero : Integer;

Nombre : String;

Programa principal
Despues de haber realizado todas las declaraciones se puede iniciar con el programa
principal. (Es posible, antes del programa, declarar las funciones y procedimientos, pero
eso se analizará posteriormente).

El programa principal inicia con la palabara reservada BEGIN y termina con la palabra
END., esta última con un punto al final.

Cada linea de código, enunciado, sentencia o instrucción completa que se escriba deberá
terminar con un punto y coma ";".

Solo se omitirá el punto y coma cuando se utiliza la palabra reservada ELSE. Aunque
puede también omitirse si la siguiente expresión es END o UNTIL.

Ya conociendo la estructura es posible escribir un primer programa:

 PROGRAM Primera_Prueba;
VAR
Entero : Integer;
CONST
Mensaje = 'Introduce un valor entero: ';
Respuesta = 'El valor es: ';
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.

Como podrá apreciarse, no es importante el orden en el que se declaran las variables y

constantes (aplicable solo al Turbo Pascal), es decir, pueden declararse primero las
variables y luego las constantes y viceversa:

PROGRAM Primera_Prueba;
CONST
Mensaje = 'Introduce un valor entero: ';
Respuesta = 'El valor es: ';
VAR
Entero : Integer;
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 y ejecución en memoria

La compilación de un programa es el paso mediante el cual traducimos dicho programa al
lenguaje maquina entendible por la computadora.

Para lograr la compilación en el entorno integrado de desarrollo de Turbo Pascal se utiliza

la opción Compile del menú del mismo nombre. Para accesar al menú se utiliza la
secuencia de teclas: [ALT] + [C], y luego se escoge la opción Compile.

Otra forma de realizar la compilación es con la secuencia de teclas: [ALT] + [F9].

Es posible compilarlo y ejecutarlo automaticamente utilizando la secuencia: [CONTROL]

+ [F9]
 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 o viceversa (Dependiendo de la
opción seleccionada actualmente).

Una vez compilado un programa en el disco es posible ejecutarlo directamente desde el

sistema operativo.

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:

Nombre := 'Juan Pérez';

{Nombre guardará la cadena "Juan Pérez"}
Resta := Numero1 - Numero2;
{Resta gurdará el resultado de la resta de Numero2 a Numero1}
Area := (Base*Altura)/2;
{Obtiene el area de un triangulo y la guarda en el identificador Area}

Es indispensable para todo programa que cuente con la capacidad de manejar entradas y
salidas de información, ya que sin estas capacidades sería un programa inútil.

Salida de datos a la pantalla

Las instrucciones que permiten mostrar datos en la pantalla de la computadora son: Write
y WriteLn. Aunque ya se hizo uso de ellas en los pequeños programas anteriores de
ejemplo, aqui se describirán a fondo.

La sintaxis de los procedimientos es la siguiente:

Write (indentificadores);
WriteLn (indentificadores);
Donde los identificadores son aquellos que contienen la información que se desea mandar
a la pantalla. Es posible utilizar varios de ellos por cada instrucción Write o WriteLn,
unicamente se separan unos de otros por comas ",". Ejemplo:

Write (Nombre, ApellidoP, ApellidoM);

Esta línea de código desplegará consecutivamente los contenidos de los identificadores

Nombre, ApellidoP y ApellidoM. En caso de que la variable Nombre almacenara el valor
'Rodrigo ', la variable ApellidoP 'González ' y la variable ApellidoM 'García', el resultado
en pantalla sería:

Rodrigo González García

Podemos obtener el mismo resultado si utilizamos la siguiente estructura:

Write (Nombre);
Write (ApellidoP);
Write (ApellidoM);
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);

lo que obtendríamos sería:

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.

Entrada de datos desde teclado

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

El identificador puede ser cualquier variable definida previamente, NO puede ser una
constante. Puede ser también un conjunto de variables, separadas entre comas, en este
caso se guardara el primer valor dado antes del [Enter] en el primer identificador
proporcionado, luego el segundo y así sucesivamente hasta el último identificador.
La diferencia en el uso de la instrucción Read con respecto a ReadLn es que en la primera,
si se le dan más datos de los que se introducirán se guardan en un buffer y se usarán en la
siguiente instrucción Read o ReadLn del programa, en cambio ReadLn ignora todo dato
posterior a los que esten definidos en la instrucción.

En caso de que se le indique a Read o ReadLn que lea un tipo específico de valor, y se le
proporcione otro diferente se generará un error y se detendrá la ejecución del programa.

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:
Tipo Rango de valores que acepta
Integer -32,768 a 32,767
Word 0 a 65535
ShortInt -128 a 127
Byte 0 a 255
LongInt -2,147,483,648 a 2,147,483,648

Al utilizar los tipos enteros es posible representar en el programa un número en formato

hexadecimal, para hacer esto solo se le antepone el símbolo "$" al valor hexadecimal, al
momento de visualizar dicho valor, o utilizarlo en alguna operación será como decimal.
Por ejemplo:

Cantidad := $10;

El valor que se guarda en "Cantidad" es 16.

 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:
Tipo Rango de valores que acepta
Real 2.9E-39 a 1.7E38
Single 1.5E-45 a 3.4E38
Double 5.0E-324 a 1.7E308
Extended 1.9E-4851 a 1.1E4932
Comp -9.2E18 a 9.2E18

Los números reales deben llevar por fuerza al menos un dígito de cada lado del punto
decimal así sea éste un cero. Como ejemplo, el número 5 debe representarse como: 5.0, el
.5 como 0.5 , etc.

En este tipo de datos se utiliza la notación científica, que es igual a la de las calculadoras,
el dígito que se encuentra a continuación de la E representa la potencia a la que se elevará
el número 10 para multiplicarlo por la cantidad a la izquierda de dicha E:

3.0E5 = 3.0 * 10^5 = 3.0 * 100000 = 300000

1.5E-4 = 1.5 * 10^-4 = 1.5 * 0.0001 = 0.00015

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:
'a' 'B' '2' '#'

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.

Es posible accesar a cada uno de los caracteres utilizando un signo # antes de su valor
correspondiente, por ejemplo, la letra A puede ser representada como #65, el retorno de
carro, o enter, se representa como #13, y así cualquier caracter.
 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).

Es posible acceder a un solo caracter de una cadena utilizando inmediatamente despues

del nombre de la misma la posición del caracter encerrada entre corchetes. Por ejemplo:

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

El tipo está definido como Boolean.

Los datos lógicos tienen una enorme aplicación en la evaluación de ciertos procesos, así
como en el control de flujo de los programas.

Otras sentencias

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:

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

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.

ReadLee un valor de teclado y lo almacena en la variable

Read (Identificador);

El identificador puede ser cualquier variable definida previamente, NO puede ser una
constante. Puede ser también un conjunto de variables, separadas entre comas, en este caso se
guardara el primer valor dado antes del [Enter] en el primer identificador proporcionado,
luego el segundo y así sucesivamente hasta el último identificador.

La diferencia en el uso de la instrucción Read con respecto a ReadLn es que en la primera, si

se le dan mas datos de los que se introducirán se guardan en un buffer y se usarán en la
siguiente instrucción Read o ReadLn del programa, en cambio ReadLn ignora todo dato
posterior a los que esten definidos en la instrucción.

En caso de que se le indique a Read o ReadLn que lea un tipo específico de valor, y se le
proporcione otro diferente se generará un error y se detendrá la ejecución del programa.
Operaciones básicas
Las operaciones básicas en Turbo Pascal están formadas por dos partes: el operador y los
operandos.

Un operador es el símbolo que le indica al programa que operación realizará y los operandos
son los datos sobre los cuales se efectuará la operación.

Los operadores de Turbo Pascal son:

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.

Operadores DIV y MOD

La división de dos números, sin importar su tipo, dará como resultado un 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:

entero := dividendo DIV divisor

entero := dividendo MOD divisor

El siguiente programa es un ejemplo del uso de los operadores aritméticos:

PROGRAM Operaciones_Básicas;

VARSuma, Resta, Multiplicacion, Division : Real; Cociente_Entero, Residuo_Entero : Integer;

BEGINSuma := 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.

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
<</b> Es menor que
>= Es mayor o igual que
<= Es menor o igual que
And y
Or o
Not no

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:

IF condición THEN instrucción ELSE otro

Donde condición es la expresión que se evaluará, en caso de ser verdadera se ejecutará la

sentencia dada como instrucción, en caso de que la condición sea falsa se ejecutara la
sentencia dada como otro. Ejemplo:

PROGRAM IF_THEN_ELSE;VARContador : Integer;BEGINFOR contador := 1 to 50

DOBEGINIF contador > 10 THEN WriteLn(Contador) ELSE WriteLn('*');END;END.

En este pequeño programa la variable Contador se incrementará desde 1 hasta 50, la

sentencia condicional IF verificará si es verdad que Contador es mayor a 10, de ser así se
escribirá en pantalla el valor de la variable, de lo contrario se escribira en la pantalla un
caracter "*". Como el contador inicia desde 1, tenemos que se imprimiran 10 asteriscos antres
del primer número, que será el 11, valor que si cumple la condición "Contador > 10" (la hace
verdadera).

La sección ELSE con su correspondiente sentencia son opcionales y pueden omitirse en caso
de no necesitarse.
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:

IF Numero > 5 THENBEGINIF Numero <10 THEN Opcion :="Numero; IF Numero <30
THEN Opcion2 :="Numero; END;

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:

FOR identificador := inicio TO fin DO instrucción;

Donde el identificador es la variable que se incrementará, inicio es el primer valor que tendrá
dicha variable y fin es el valor hasta el cual se incrementará la misma; instrucción es la
sentencia (sencilla o compuesta) que se ejecutará en cada incremento de la variable.

El siguiente ejemplo escribe los números del 1 al 50 en pantalla. La variable utilizada es

"Numero".

PROGRAM Ciclo_FOR;VARNumero : Integer;BEGINFOR Numero := 1 to 50

DOWriteLn(Numero);END.

Una de las limitaciones de los ciclos FOR es que una vez iniciado el ciclo se ejecutará el
número de veces predefinido sin posibilidad de agregar o eliminar ciclos.

Es posible hacer que un ciclo cuente hacia atrás, es decir que la variable en lugar de
incrementarse se decremente. Para ésto cambiamos la palabra TO por DOWNTO, y
colocamos el valor mayor a la izquierda y el menor a la derecha.

Ejemplo:

PROGRAM Ciclo_FOR_2;VARNumero : Integer;BEGINFOR Numero := 50 DOWNTO 1

DOWriteLn(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:

WHILE condición DO instrucción

Donde condición es la condición que se evaluará, mientras ésta sea verdadera se ejecutará la
instrucción, que es una sentencia simple o compuesta.

Un programa que escriba los números del 1 al 50, utilizando el ciclo WHILE se vería como
sigue:

PROGRAM Ciclo_WHILE;VARNumero : Integer;BEGINNumero := 1;WHILE Numero <=

50 DOBEGINWriteLn (Numero);Numero := Numero +1;END;END.

Al final del programa la variable Numero guardará el valor 51, que fué el valor que no
cumplió con la condición establecida en el ciclo WHILE.

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;VARNumero : Integer;BEGINNumero := 1;REPEATWriteLn

(Numero);Numero := Numero + 1;UNTIL Numero = 50;END.

Para crear un buen programa es necesario dotarlo con capacidad de desición con base en las
variables o eventos definidos por el programador, para que el programa sea aplicable en un
entorno más generalizado y no solo para un problema específico.

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.

El siguiente programa ilustra el uso de la forma CASE, el programa preguntará un número al

usuario y lo clasificará de acuerdo a su valor.

PROGRAM Case;VARNumero : Integer;BEGINWriteLn('Introduzca un número entero del 1

al 5: ');ReadLn(Numero);

CASE Numero OF1 : 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.

El uso de GOTO no es aconsejable ya que destruye el modelo de la programación

estructurada que es la que se utiliza en Turbo Pascal, además se cuenta con las estructuras de
datos anteriores que hacen casi innecesario su uso.

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 antes que la de constantes y variables, la
palabra reservada para su declaración es LABEL. El nombre de la etiqueta es un nombre de
un identificador como cualquier otro, pero al utilizarse debe terminar con dos puntos ":".

La sintaxis del comando es:

GOTO etiqueta;

Ejemplo:

PROGRAM Uso_del_GOTO;LABELEtiqueta;BEGINWriteLn('Esta linea si se escribirá');

GOTO Etiqueta;WriteLn('Esta linea no se escribirá'); Etiqueta:WriteLn('Se efectuó el

brinco');END.

Nota: normalmente se debe agregar la libreria CRT , despues del PROGRAM, PARA poder
usar el comando CLRSCR, Que nos permite borrar la pantalla antes de correr el programa.

Ejemplos.

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.

***********************************************************

PROGRAM EJER2B;

USES CRT;

VAR x,y:REAL;
VAR suma,rest,mult:REAL;

VAR divi:REAL;

{suma, resta, multiplica y divide 2 numeros reales}

BEGIN

WRITELN ('Este programa suma, resta, multiplica y divide:');

WRITELN ('Escriba dos numeros reales');

WRITELN (' ');

Read(x);

Read(y);

suma:=x + y;

rest:=x - y;

mult:=x * y;

divi:=x / y;

ClrScr;

WRITE ('SUMA:'); WRITELN (suma:3:0);

WRITE ('RESTA:'); WRITELN (rest:3:0);

WRITE ('MULTIPLICACION:'); WRITELN (mult:3:0);

WRITE ('DIVISION:'); WRITE (divi:5:2);

END.

******************************************************************

PROGRAM EJER4B;

USES CRT;

VAR base,altura:REAL;

VAR area:REAL;

BEGIN
{Este programa sirve para calcular el area de un triangulo}

ClrScr;

WRITELN ('PARA CALCULAR EL AREA DE UN TRIANGULO:');

WRITELN (' ');

WRITE ('ESCRIBE LA BASE: '); READLN (base);

WRITE ('ESCRIBE LA ALTURA: '); READLN (altura);

WRITELN (' ');

area:=(base * altura) / 2;

WRITE ('EL AREA DEL TRIANGULO ES: '); WRITE (area:5:2);

END.

Program Saludo; Var nombre: string[20]; Begin Writeln ('Introduce tu nombre, por
favor'); Readln (nombre); Write ('Hola ',nombre); Readln;End.

******************************************************

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.

PROGRAM EJER10B;

USES CRT;

VAR a,b,c:REAL;

VAR resultado:REAL;

BEGIN

{Calcula la incognita positiva de una ecuacion de 2º grado}

ClrScr;

WRITE ('Para calcular la incognita positiva de una ecuacion');

WRITE (' de segundo grado escriba todas las variables:');

WRITELN (' ');

WRITELN (' ');

WRITE ('Escriba a: '); READLN (a);

WRITE ('Escriba b; '); READLN (b);

WRITE ('Escriba c; '); READLN (c);

WRITELN (' ');

resultado:=(-b +sqrt(sqr (b) - 4*a*c))/(2*a);

WRITE ('RESULTADO: '); WRITE(resultado:5:2);

END.

PROGRAM EJER15B;

USES CRT;

VAR arista:REAL;

VAR area, volumen:REAL;

BEGIN

{Sirve para calcular el area y el volumen de un tetraedro}

WRITELN ('PARA CALCULAR EL AREA Y VOLUMEN DE UN TETRAEDRO: ');

WRITE ('ESCRIBA EL VALOR DE LA ARISTA: '); READLN (arista);

WRITELN (' ');

area:= 2 * sqr(arista) * sqrt(3);

volumen:= ((sqr(arista) * arista) / 3) * sqrt(2);

WRITE ('AREA DEL OCTAEDRO: '); WRITELN (area:5:2);

WRITE ('VOLUMEN DEL OCTAEDRO: '); WRITE (volumen:5:2);

END.

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.

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

**********************************************************

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.

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.

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.

PROGRAM EJER18B;

USES CRT;

VAR a,b,c:REAL;

VAR resultado1,resultado2:REAL;

BEGIN

{Calcula ecuaciones de segundo grado}

ClrScr;

WRITE ('ESTE PROGRAMA SIRVE PARA CALCULAR ECUACIONES ');

WRITELN ('DE SEGUNDO GRADO');

WRITELN (' ');

WRITELN ('Introduzca: a, b y c: ');

WRITELN (' ');

READLN (a);

READLN (b);

READLN (c);

resultado1:=(-b + sqrt(sqr(b) - 4*a*c)) / (2*a);

resultado2:=(-b - sqrt(sqr(b) - 4*a*c)) / (2*a);

WRITELN ('RESULTADO DE LA EXPRESION: ');

WRITE ('VALOR 1: '); WRITELN (resultado1:5:2);

WRITE ('VALOR 2; '); WRITE (resultado2:5:2);

END.

PROGRAM EJER22B;

USES CRT;

VAR horas, minutos, segundos:INTEGER;

VAR cantidad:INTEGER;

BEGIN

ClrScr;

WRITE ('Escriba los segundos para transformarlo a horas,');

WRITELN (' minutos y segundos');

READLN (cantidad); {Es el numero de segundos que se introducen}

WRITELN ('');

horas:= cantidad div 3600;

minutos:= (cantidad mod 3600) div 60;

segundos:= (cantidad mod 3600) - (minutos * 60);

{Los segundos son: las horas - los minutos pasados a segundos}

WRITELN ('EN ' ,cantidad, ' SEGUNDOS HAY: ');

WRITE (horas,' horas ',minutos,' minutos ',segundos,' segundos');

END.