0

Trabajo realizado por :

Patricia García Gómez

Francesc Nadal i Aura

Índice1. INTRODUCCIÓN...................................................................................................................................3

1. INTRODUCCIÓN...............................................................................................................................32. ESTRUCTURA GENERAL DE LOS PROGRAMAS..............................................................4

2.1 TECLAS DE ACCESO RAPIDO............................................................................................................52.2 TIPOS DE VARIABLES........................................................................................................................72.3 ESTRUCTURA ARRAY........................................................................................................................92.4 CONSTANTES..................................................................................................................................102.5 FUNCIONES.....................................................................................................................................11

2.5.1 Sentencias.........................................................................................................................112.5.2 Funciones de formato....................................................................................................20

3. TEORÍA LLEVADA A LA PRÁCTICA......................................................................................253.1 SALUDO..........................................................................................................................................253.2 SUMA..............................................................................................................................................263.3 RECTÁNGULO................................................................................................................................273.4 CÍRCULO.........................................................................................................................................283.5 POSITIVO.......................................................................................................................................303.6 VECTORES.....................................................................................................................................313.7 SALUDO 2.....................................................................................................................................333.8 CONCATENAR................................................................................................................................343.9 AZAR...............................................................................................................................................353.10 REDONDEO..................................................................................................................................363.11 MAYOR DE EDAD.......................................................................................................................373.12 CONTRASEÑA.............................................................................................................................383.13 CADENAS.....................................................................................................................................393.14 SENTENCIA FOR........................................................................................................................403.15 Letra...........................................................................................................................................40

1

1. Introducción

El pascal es un lenguaje de programación de alto nivel y de propósito general que ha derivado del “ALGOL-60” y fue diseñado pa-ra enseñar técnicas de programación estructurada. Es de alto nivel porque su repertorio de instrucciones lo hacen próximo a los lengua-jes humanos y a los procesos humanos de pensamiento. Sus instruc-ciones o sentencias se componen de expresiones de apariencia alge-braica y de ciertas palabras inglesas como BEGIN, END, READ, WRI-TE, IF, THEN, REPEAT, WHILE, DO.

La programación orientada a objetos o POO (OOP según sus siglas en inglés) es un paradigma de programación que usa obje-tos y sus interacciones, para diseñar aplicaciones y programas infor-máticos. Está basado en varias técnicas, incluyendo herencia, abs-tracción, polimorfismo y encapsulamiento. Su uso se popularizó a principios de la década de los años 1990. En la actualidad, existe va-riedad de lenguajes de programación que soportan la orientación a objetos.

En este manual vamos a hablar del programa Free Pascal. El Free Pascal es un compilador Pascal portable, libre y de código abierto, que representa una alternativa a los productos comerciales Turbo Pascal y Delphi.

2

A continuación detallaremos como usar este programa sin tener noción alguna de programación.

2. Estructura general de los programas

Todos los programas creados en Free Pascal tienen una estruc-tura general, fija en todos los programas. Dicha estructura es la si-

guiente:

En primer lugar empezamos el programa con la palabra Program e introducimos el nombre del programa a realizar.A continuación introducimos el apartado Uses, donde declaramos las bibliotecas que tengamos la necesidad de utilizar. En la mayoría de casos utilizaremos la biblioteca crt.Antes de comenzar la estructura para el programa con un begin intro-ducimos las variables. El apartado lo introducimos con la palabra

3

Var, donde declaramos todas la variables que vayamos a usar y de que tipo son las susodichas.Siempre que empezamos la parte operativa las líneas del programa van dentro del conjunto de Begin […] End.Dentro del conjunto Begin/End, es donde procederemos a escribir tantas líneas de programa como nos hagan falta. En este apartado es donde pondremos las sentencias, las funciones de formato, y en defi-nitiva todo lo que haya que escribir para crear el programa.Por último, después de begin introduciremos un clrscr; para que el programa nos borre información del programa cuando vayamos a eje-cutarlo. Esta es la información que borra:

Y antes del End siempre se pone un readkey; lo cual sirve para que el ordenador espere hasta que el usuario tecleé una tecla para conti-nuar con el programa.

SIEMPRE después de cada línea de programa debemos poner “ ;; ”. Dentro del conjunto

2.1 Teclas de acceso rapido

Pantalla de edición y pantalla de ejecución.Las teclas que hemos usado en los programas de acceso rápido son:- Alt. + F5: Esta tecla rápida nos permite cambiar de la pantalla de edición a la pantalla de ejecución, y ver qué hace el programa con las instrucciones que le hemos dado.

4

- ctrl. + F5: Esta tecla sirve para mover la pantalla de edición.- ctrl. + F9: Con esta tecla rápida nos permite poner el programa en ejecución.

- Alt. + F9: Con la combinación de estas teclas compilamos el programa, y comprobamos si las instrucciones están correctamente hechas.Si las instrucciones que le damos están correctas nos aparece en pan-talla un recuadro, donde pondrá: Press any key. Esto quiere decir que el programa está esperando a que pulses una tecla cualquiera, ya que no tienes ningún error y está todo correcto.

5

Si por el contrario tienes errores en la pantalla aparecerán los errores que tienes y en qué líneas están:

En la pantalla de arriban te pone cuántos errores tienes – en el caso del ejemplo dos – en el apartado “Total errors”, y en la pantalla verde de abajo te escribe cuales son los errores y en qué líneas se en-cuentran – en este ejemplo el error se encuentra en la línea 36,5 y se trata de que falta un; al final de un writeln- .- F2: Con esta tecla se guarda el programa que se haya realizado has-ta ese momento de forma instantánea.

2.2 Tipos de variables

Son varios los tipos de variables que podemos introducir según el programa que vayamos a realizar posteriormente. En esta sección se declaran todas las variables asociando a cada una un identificador, un tipo y, opcionalmente, un valor inicial.Se pueden combinar varios identificadores en una misma declaración de variable si se trata de variables del mismo tipo. Si se declara valor inicial, afectará a todas.Las variables pueden ser para números enteros, no enteros, para le-tras o nombres y constantes.A continuación explicamos las variables más frecuentes y que hemos utilizado nosotros:

Tipo RealLa variable de tipo Real se expresa en el programa - después

de introducir la variable seguida de una coma – con dos puntos (:) y la palabra Real, y punto y coma (;). Con ello declaramos la variable de tipo real, la cual va de 0 a +∞, es decir, números reales.

6

En este tipo de variable si queremos que el programa nos de el núme-ro con un número determinado de decimales tendremos que introdu-cir K:0:2 – por ejemplo -, siento K el número real, cero el número de cifras significativas, en este caso el cero quería decir que cogiera to-das, y 2 el número de decimales que después tendría el número cuando ejecutaras el programa.

Sin embargo, si queremos introducir varias variables del tipo real no hace falta que recurramos a poner en diferentes líneas cada variable seguida de la palabra Real. Podemos poner varias variables con una coma y la siguiente variable. Cómo podemos observar en la foto anterior.

Tipo EnteroLa variable de tipo entero se expresa en el programa - después

de introducir la variable seguida de una coma – con dos puntos (:) y la palabra Integer, y punto y coma (;).De este modo declaramos la variable como un número entero, el cual puede ser negativo o positivo, pero siempre entero.En este tipo de variable no hace falta determinarle cuales son el nú-mero de decimales que quieres obtener pues los números enteros son sin decimales. Los valores de tipo integer se representan con dígitos decimales. No se admiten ni el punto ni la coma. También se pueden usar enteros negativos pero hay que tener en cuenta que un entero negativo como -32, por ejemplo, no es una constante, es una expresión formada por el signo (-) y el valor entero 32. El uso de enteros negativos en expre-siones aritméticas complejas puede dar lugar a resultados distintos de los esperados si no se interpreta bien esta cuestión.Las operaciones de entrada (lectura) permiten suministrar el signo "más" o "menos" con los valores enteros. En las operaciones de sali-da, el signo de los valores negativos se incluye automáticamente.Los datos de tipo integer pueden ser sometidos a operaciones arit-méticas.

Las variables se pondrán de la misma forma que las de tipo real:

Tipo CarácterLa variable de tipo carácter se expresa en el programa - des-

pués de introducir la variable seguida de una coma – con dos puntos (:) y la palabra Char, y punto y coma (;).

7

El tipo Char depende del código de caracteres empleado por la má-quina. El más utilizado es el código ASCII. Una variable o constante ti-po Char puede contener un solo carácter especificado entre apóstro-fes. Las variables quedaran en el programa de la siguiente forma:

Tipo CadenaLa única variable de tipo cadena que hemos utilizado es Ansis-

tring. Ésta corresponde a las nuevas cadenas largas, de longitud va-riable. Estas cadenas son asignadas de forma dinámica, incluyen un contador de referencias, e implementan la técnica de copia por escri-tura (copy-on-write). El tamaño de tales cadenas es casi ilimitado, pues pueden almacenar hasta dos millardos de caracteres. También están basados en el tipo ANSIChar.

2.3 Estructura Array

Es una estructura homogénea de datos de tamaño constante accediendo a cada uno de sus elementos mediante un identificador común y uno o varios índices.Todos los elementos del array son del mismo tipo. Además el número de ellos no varía durante la ejecución del programa.En la estructura Array accedemos a un elemento de la estructura mediante un identificador común, el nombre del array, y con el valor que toman uno o varios índices. Al número de índices necesarios paradesignar un elemento del array se le denomina dimensión del array.El número máximo de valores posibles que puede tomar cada índice se denomina rango de esa dimensión o índice. Los valores han de ser consecutivos, por lo que el índice ha de ser de un tipo ordinal.Los componentes de un "array" pueden estar estructurados. Una va-riable de tipo "array" cuyos componentes también son "arrays" se llama matriz.

A continuación expondremos un ejemplo de dicha estructura:

8

Como se puede observar en el ejemplo nosotros hemos utiliza-do la estructura Array para decirle al programa cuántos son los vec-tores que utilizaremos para realizar el programa. En este ejemplo han sido 5, por eso pone: array [1…5].En pascal para decir que lo que queremos exponer va de a hasta b se pone entre medias tres puntos. Siendo a y b los límites que queramos establecer.

2.4 Constantes

Una constante es un dato cuyo valor no puede cambiar durante la ejecución del programa. Recibe un valor en el momento de la com-pilación y este permanece inalterado durante todo el programa. Las constantes se declaran en una sección que comienza con la pala-bra reservada const. Después de declarar una constante ya puedes usarla en el cuerpo principal del programa. Tienen varios usos: ser miembro en una expresión, en una comparación, asignar su valor a una variable, etc. Las constantes tiene lugar a continuación de las variables y la estruc-tura array

9

2.5 Funciones

A la hora de hacer un programa ligeramente grande existen de-terminados procesos que se pueden concebir de forma independien-te, y que son más sencillos de resolver que el problema entero. Ade-más, estos suelen ser realizados repetidas veces a lo largo de la eje-cución del programa. Estos procesos se pueden agrupar en una fun-ción, definida para que no tengamos que repetir una y otra vez ese código en nuestros scripts, sino que simplemente llamamos a la fun-ción y ella se encarga de hacer todo lo que debe.

Así que podemos ver una función como una serie de instruc-ciones que englobamos dentro de un mismo proceso. Este proceso se podrá luego ejecutar desde cualquier otro sitio con solo llamarlo. Por ejemplo, en una página web puede haber una función para cambiar el color del fondo y desde cualquier punto de la página podríamos lla-marla para que nos cambie el color cuando lo deseemos.

Una función es un modulo de un programa separado del cuerpo principal, que realiza una tarea especifica y que puede regresar un valor a la parte principal del programa u otra función o procedimiento que la invoque.Hay dos tipos de funciones:

2.5.1 Sentencias

La parte ejecutable de un programa está formada por senten-cias que constituyen la expresión de algoritmos que, aplicados a las estructuras de datos diseñadas, producen acciones enfocadas a la ob-tención de resultados útiles.En Pascal, las sentencias ejecutables se pueden clasificar en simples y estructuradas.

Sentencias simples: - Asignación. - Sentencia vacía. - Llamada a procedimiento. - Sentencia GOTO. Sentencias estructuradas: - Sentencia compuesta. - Condicionales: IF-THEN-ELSE - Repetitivas: WHILE, REPEAT, FOR.

Las sentencias estructuradas contienen a sentencias simples o a otras sentencias estructuradas que deben ser ejecutadas en orden, de forma repetitiva o cuando se cumplen condiciones determinadas.

10

Una sentencia estructurada se puede usar en cualquier lugar donde está permitida una sentencia simple. En lo sucesivo se usará el tér-mino sentencia para designar a una sentencia simple o estructurada indistintamente.

Sentencias simples:- Asignación:

Reemplaza el valor actual de una variable o función por otro va-lor especificado por una expresión. En tiempo de ejecución, se evalúa la expresión y el resultado se asig-na a la variable representada a la izquierda del signo ( := ).Como identificador se puede usar el nombre de una función o de cual-quier variable.La variable (o función) y la expresión deben ser del mismo tipo, admi-tiéndose solamente las siguientes excepciones:1. Que el tipo de la variable sea real y el tipo de la expresión: entero o un subrango de entero2. Que el tipo de la expresión sea un subrango del tipo de la variable y viceversaEste tipo de sentencia se expresa en Pascal de la forma :=.

- Sentencia vacía:No produce otro efecto que avanzar el control de la ejecución

del programa a la sentencia siguiente.Se puede representar por dos delimitadores (;) seguidos.Un caso de sentencia vacía se presenta cuando se escribe el punto y coma después del último componente de una sentencia compuesta. También se suele presentar en las sentencias IF-THEN-ELSE anidadas.

- Sentencia GOTO:La sentencia GOTO produce la bifurcación incodicional del con-

trol a una sentencia identificada por una etiqueta específica.La sentencia GOTO debe estar dentro del alcance de declaración de la etiqueta. Con GOTO no se puede saltar al interior de una sentencia estructurada desde fuera.En los tratados sobre PASCAL se recomienda vivamente NO USAR es-ta sentencia porque rompe la estructura de los programas. En algu-nos compiladores no está implementada.

A continuación expondremos un ejemplo de dicha sentencia:

11

Sentencias estructuradas:- Sentencia compuesta:Es una agrupación de sentencias que pueden ejecutarse secuencial-mente como si fuesen una sentencia simple. Expresión: begin (sentencia) ; .... end

Se pueden agrupar sentencias simples y estructuradas, que pueden ser compuestas a su vez.Las sentencias componentes deben de estar separadas por el delimi-tador (;). No es necesario escribirlo entre la última sentencia y el deli-mitador END, pero es recomendable hacerlo para que no se olvide en caso de añadir otras sentencias posteriormente.

- Sentencias condicionales:Las sentencias condicionales producen la ejecución de una sen-

tencia según el valor de una expresión de control. La sentencia de condición que nosotros hemos dado es: Sentencia if-then-else: La expresión que sigue a IF representa la condición a eva-luar.

12

La sentencia que sigue a THEN se ejecuta sólo si el valor de la condición es TRUE; en caso contrario se ejecuta la sentencia que sigue a ELSE (o no se ejecuta ninguna si no hay parte ELSE). La sentencia detallada de operaciones es la siguiente: 1. Evaluar la condición. 2. Si es TRUE : ejecutar la parte THEN, y seguir con el paso 4. 3. Si es FALSE : ejecutar la parte ELSE, y seguir con el paso 4. 4. Continuar con el resto del programa. No se puede suponer nada sobre el valor de la condición. El objeto de una clausula THEN o ELSE puede ser una sen-tencia simple o estructurada, incluso otra sentencia IF-THEN-ELSE. Este caso se interpreta como si los delimitadores BEGIN y END estuvieran incluidos Hay que notar que después de THEN y ELSE no debe escri-birse el punto y coma. Si se escribe precediendo a ELSE, se termina-rá allí la sentencia IF y se producirá un error de compilación. Cuando se anidan varias sentencias IF, hay que tener en cuenta que la clausula ELSE afecta a la IF-THEN más próxi-ma. La sintaxis de dicha sentencia es: if (expresión lógica) then (sentencia1) else (sentencia2)

Y el logaritmo es:

13

A continuación expondremos un ejemplo donde se utiliza dicha sen-tencia:

- Sentencias repetitivas:Permiten programar la repetición de un grupo de sentencias

mediante la construcción denominada CICLO o BUCLE. El grupo de sentencias que tienen que repetirse se llama "rango" del ciclo. El nú-mero de veces que ha de repetirse el rango está determinado por la "sentencia de control" de ciclo. También suele existir una sentencia "final de ciclo" que indica el final de las sentencias que componen el rango.Hay dos formas de ciclo: el ciclo condicional y el ciclo con contador.En PASCAL, el ciclo condicional se consigue con las sentencias WHILE y REPEAT; y para el ciclo con contador está la sentencia FOR.

14

Sentencia While: Indica al ordenador que se ejecuten una o más sentencias mientras se cumpla una determinada condición. La condi-ción viene determinada por una variable o expresión booleana.

Formato: while (condición) do begin (sentencia1); ... (sentencia2); end; while (condición) do (sentencia);

Puedes añadir las sentencias que desees. N será el número de sentencia que hayas decidido poner o requieras para reali-zar Esta sentencia comprueba inicialmente si la condición es verdadera. Si la condición es verdadera se ejecutan las sentencias mientras la condición de su enunciado sea verdadera y finaliza cuando la condición es falsa. Dado que la condición puede ser falsa inicialmente, es decir antes de comenzar el bucle, habrá casos en que el bucle no se ejecute. Las características del bucle while son: - Se ejecuta mientras la condición sea verdadera, y dentro del bucle debe existir, por lo menos, una sentencia que modifi-que el valor de la variable o expresión, de lo contrario se puede producir una situación de bucle infinito. Si la expresión ló-gica es falsa al comenzar el bucle, éste no se realizará. - Para ejecutar un grupo de sentencias, hay que construir una sentencia compuesta con los delimitadores BEGIN y END.

El logaritmo que sigue la sentencia while es el siguiente:

15

La secuencia detallada de operaciones que sigue dicha sentencia es la siguiente:

1. Evaluar la condición. Si es FALSE, seguir con el paso 4. 2. Ejecutar la sentencia componente, sabiendo que la condición es TRUE. 3. Volver al paso 1. 4. Sabiendo que la condición es FALSE, seguir con el resto del programa.

A continuación expondremos un ejemplo de dicha sentencia:

16

Sentencia REPEAT – UNTIL: Ejecuta las sentencias comprendidas entre las palabras reservadas REPEAT y UNTIL hasta que la expresión o va-riable sea verdadera. Formato: repeat begin (Sentencia); (Sentencia); ... end; until (condición);

Las características del bucle repeat son: - Se ejecutan siempre una vez, por lo menos, y la termi-nación del bucle se produce cuando el valor de la expresión lógica o condición de salida es verdadera. Se ejecuta hasta que la expresión es verdadera, es decir, se ejecu-ta mientras la expresión sea falsa. Entre las palabras reservadas REPEAT y UNTIL se pue-den escribir varias sentencias sin necesidad de utilizar los delimitadores BEGIN y END. Aquí actúa UNTIL como indicador de final de rango. En la ejecución, la expresión es evaluada después de que han sido ejecutadas las sentencias; por tanto, el rango del bucle se ejecuta una vez, por lo menos, siempre.

A continuación expondremos el logaritmo de dicha sentencia:

17

A continuación expondremos un ejemplo de dicha senten-cia:

Sentencia FOR: Repite la ejecución de una o varias sentencias un núme-ro fijo de veces previamente establecido. Necesita una variable de control del bucle que es necesariamente de tipo ordinal, ya que el bucle se eje-cuta mientras la variable de control toma una serie consecu-tiva de valores de tipo ordinal, comprendidos entre dos valo-res extremos (inferior y superior).

18

Las características del bucle FOR son: Aunque a primera vista pueda resultar más atractivo FOR, existen limitaciones en su aplicación ya que en el bucle FOR siempre se incrementa o decrementa (de uno en uno) los valores de la variable de control de bucle y no de dos en dos o de tres en tres, o con valores fraccionarios. El número de iteraciones de un bucle FOR siempre es fi-jo y se conoce de antemano: Valor final - Valor inicial +1. En resumen permite construir bucles repetitivos contro-lados por un contador. Con FOR se especifica la ejecución repetitiva de una sentencia según el valor de una varia-ble de control que se incrementa o decrementa automáticamente. Las sentencias que se repiten (rango del bucle) no de-ben modificar el valor de la variable de control. El test de final de bucle se realiza antes de ejecutarse la sentencia FOR; por tanto, es posible que el bucle no se ejecute ninguna vez. En la forma TO, si la variable de control tiene un valor menor o igual que el valor final, se ejecuta el bucle y se incrementa el valor de la variable de control. Cuando el valor de la variable de control es mayor que el valor fi-nal, se da por terminada la ejecución del bucle. Cuando el bucle termina de forma natural (se completa), el valor de la variable de control queda indefinido. Si ter-mina por la acción de una sentencia GOTO, antes de completarse, la variable de control retiene el último va-lor asignado. La sentencia FOR proporciona el modo más natural para operar con "arrays". A continuación expondremos la sintaxis y el algoritmo de dicha sentencia:

for (variable_control := valor_inicial) to (valor_final) do (sentencia)

19

Y por último expondremos un ejemplo de dicha sen-tencia:

Respecto a estas tres sentencias deberemos utilizar la sentencia o es-tructura FOR cuando se conozca el número de iteraciones, y siempre que la variable de control de bucle sea de tipo ordinal. Se deberá utili-zar la estructura REPEAT-UNTIL cuando el bucle se realice por lo me-nos una vez, y en todos los demás casos utilizar la sentencia WHILE.

2.5.2 Funciones de formato

Función Text Color:

20

La función text color cambia el color de fuente de todo lo que impri-mas en pantalla hasta que no definas un nuevo color. Estos son los valores que puedes incluir: Con dichos colores cada vez que se quiera que el texto que vaya a salir en pantalla lo haga de un determinado color se pondrá: Text color(color deseado);

Y así es como quedará al ejecutar el programa:

21

- Función Write:El procedimiento write escribe en un registro del archivo el con-

tenido de una variable de memoria definida del mismo tipo.Cuando el usuario está creando el programa y quiere que salga algún, variable, etc… usará la función write. Dicha función sacará lo que ha-ya dentro de ella en la pantalla de ejecución cuando se esté llevando a cabo el programa.

Si queremos – por ejemplo – el programa pide un dato al usuario y después queremos que aparezca seguido de lo que se ha escrito en esta función, o queremos que aparezca una variable determinada lo único que hay que hacer es cerrar con ‘, poner una coma y la varia-ble. Si dicha variable se pone al final del write no hará falta poner na-da más, si por el contrario se quiere seguir escribiendo habrá que po-ner otra coma, una ‘ y continuar escribiendo. La sintaxis de la función es: Write (‘ texto que se quiere que salga en pantalla ‘);

A continuación expondremos un ejemplo:En esta foto vemos como hay que expresarlo cuando se está creado el programa:

Y en esta otra cómo queda cuando se está ejecutando dicho progra-ma:

Como observamos en el ejemplo anterior, si se quiere que al ejecutar-se el programa escriba en la línea siguiente se tendrá que poner un ln siguiendo al write.

- Función Read:

22

La función read sirve para ingresar en el programa aquellas va-riables introducidas por el usuario que está utilizando el programa. Di-chas variables será las respuestas que se dará a lo que el programa pide y que se utilizan después para seguir con éste.La sintaxis de la función read es: Read (variable que quieras ingresar en el programa);

Esta función puede ser sustituida incluyendo la variable en la función write.En esta función también puede ir seguida de ln.

- Función Trunc:La función trunc se usa para truncar un número real. La sintaxis de di-cha función es la siguiente:

Trunc (la variable que quieras truncar);

Esta función sólo puede ser utilizada con las variables real. Pues cual-quier otro tipo de variable no se podría truncar.

- Función round:La función round se usa para truncar un número real. La sintaxis de dicha función es la siguiente:

round (la variable que quieras redondear);

Esta función sólo puede ser utilizada con las variables real e integer. Pues cualquier otro tipo de variable no se podría redondear.

- Función delay: El programa Pascal cuando está en ejecución espera a que el

usuario presione una tecla para continuar con su función. Una opción a esto es la función delay. Dicha función hace que el programa siga en ejecución cada cierto tiempo. Tiempo que se impondrá en la edi-ción del programa.El tiempo será programa con una constante. Y después a lo largo del programa se pondrá la siguiente sintaxis para hacerlo después funcio-nar: Delay (t) , siendo t el tiempo.

A continuación exponemos un ejemplo de dicha función:

23

- Función div: En Pascal se puede dividir dos números y te proporciona el re-

sultado, o también se puede vivir y que aparte del resultado se obten-ga el resto. Para hacer esto últimos se utiliza la función div.En resumen en el caso de la división, no importando los números que dividamos, el resultado será un número real, para obtener un resulta-do entero, debemos de utilizar el operador div.La sintaxis la exponemos en el siguiente ejemplo:

- Función mod: Esta función sirve para que Pascal calcule y saque por pantalla

el resto de una división en número entero.A continuación expondremos un ejemplo de dicha función:

- Funciones básicas de cálculo:Las funciones básicas de pascal para realizar programas son:

Para sumar dos variables se utilizará +, para restarlas -, para multipli-carlas * y para dividirlas /.

- Función Random:Si queremos realizar números al azar para algún programa con

Free Pascal debemos utilizar la función Random. La sintaxis de dicha función es: Randomize; P(siendo P la variable):=Random(hasta el número que quere-mos que elija al azar)

En esta función cuando queremos – por ejemplo – que los núme-ros al azar sean del cero al 30 tenemos que poner en el paréntesis 29, es decir, un número menos del que queremos. Y así irá del 0 hasta el número que queramos.Sin embargo, si quieres que sea a partir del uno debemos sumar 1 fuera del paréntesis.

24

Número al azar que va del 0 a X:

Número al azar del 1 a X:

- La función Length:La función Length proporciona la longitud lógica de una cadena de caracteres.

3. Teoría llevada a la práctica

3.1 Saludo

Empezamos escribiendo en nombre del programa, en este caso Saludo, a continuación declaramos la biblioteca crt;Empezamos el programa con un Begin y en la línea siguiente, escribimos un clrscr; para que a la hora de ejecutar el programa nos borre toda la información del FreePascal.En la línea siguiente escribimos un Write (‘ ’) o Writreln(‘ ’), este ultimo hace que al escribir lo que le previamente hemos introducido nos vaya a la siguiente línea del programa; con el texto que queremos que salga en la pantalla.

25

Acabamos con un readkey;, el programa espera hasta que pulses cual-quier tecla y un End. para finalizar el programa.Con todo lo descrito anteriormente, el programa una vez ejecutado, nos escribe en la pantalla lo que hemos introducido en el Write

Esquema del programa

Program Suma;Uses crt;

BeginClrscr;Write(‘ X ’);Readkey;

End.

3.2 Suma

Empezamos nombrando el programa como queramos, en este caso se llamará suma.Declaramos la biblioteca que vamos a utilizar, crt.Declaramos 3 variables a utilizar, n1 (1º sumando), n2 (el 2º suman-do) y rs (el resultado de la suma).Una vez que por pantalla nos salga “Ingrese el 1º número a sumar” utilizamos un Read(n1) o Readln(n1), este último para ir a la línea si-guiente, para que el programa lo lea y posteriormente los sume.Después de que nos lea el 2º número (n2), al la variable -rs- le asig-namos con “: = “ la suma de (n1) y (n2) .

26

Cuando queremos que el programa nos escriba el resultado, dentro del write escribimos depuse del la parte que va entre las comillas, ‘ X ’, escribimos una coma y seguidamente ponemos rs. De esta manera hacemos que el programa escriba de manera automatica el resultado, si que nosotros tengamos que hacer nada.Con todo lo descrito anteriormente el programa nos pide dos numeros y seguidamente los suma y nos saca el resultado por pantalla.

Estructura programa

Progam Suma;Uses crt;Var N1, n2, rs: integer;

Beginclrscr; Write(‘ X ’);Readln(n1);Write(‘ X ’);Readln(n2);rs: n1+n2;Write(‘ X ’,rs);readkey;

End.

3.3 Rectángulo

Empezamos nombrando el programa como queramos, en este caso se llamará rectángulo.

27

Declaramos la biblioteca que vamos a utilizar, crt.Declaramos las variables a utilizar: base(b1), altura(h2) y área(ar); to-das de carácter integer (numero entero con signo).Escribimos una breve introducción de que es lo que el progrma nos va a hacer.Escribimos un Writeln(); para dejar una línea en blanco entre linea y linea que saldra en el programa.

Seguidamente después de un write en el que nos pida que in-gresemos la base, una vez escrita y mediante un readln le decimos al programa que esa sera la variable b1 [readln(b1)].Seguidamente le escribimos la altura después que un write nos lo vuelva a perdir y con un readln hacemos los mismos pasos descritos para la base.A la variable ar (area), le asignamos que es la suma de b1(base)+h2(alura).Una vez calculada, el programa, mediante un write nos la muestra por la pantalla.Con todo lo descrito anteriormente, el programa nos pide que le in-gresemos la base y altura de cualquier rectangulo y el nos calcula no area.

Estructura del programa

Progam Rectángulo;Uses crt;Var b1, h2, ar: integer;

Beginclrscr; Writeln(‘ X ’);Writeln();Writeln(‘ X ’);Write(‘ X ’);Readln(b1);Write(‘ X ’);Readln(h2);ar:= b1+b2;Write(‘ X ’,ar);readkey;

End.

3.4 Círculo

28

Empezamos nombrando el programa como queramos, en este caso se llamará circulo.Declaramos la biblioteca que vamos a utilizar, crt.Declaramos las variables a utilizar: radio(ra), longitud(long), área(ar) de tipo real.Definimos una constante (pi) como 3,1415926, para que a la hora de escribira lo tengamos que poner si valor cada vez y tambien para no ponerla en en las variable, pues ya la hemos definido anteriormente como constante.Empezamos el programa con un write donde nos explica en que con-sitira el programa.Seguidamente después de un write en el que nos pida que ingrese-mos la el radio de la circunferencia, utilizamos un read para que el va-lor que hemos escrito lo tome como “ra”.Una vez teniento “ra”, le asigamos a la variable ar(area) pi*radio*ra-dio (ra^2).Una vez haya hecho el calculo, le decimos que nos lo escriba por pan-talla.Despues que que nos haya sacado por pantalla el área de la circunfe-rencia, le asignamos a la variable long(longitud) 2*pi*radio.Una ves hecho el cálculo, le decimos que nos lo muestre por la panta-lla.En los 2 resultados, area y longitud, le decimos al programa que nos lo ponga solo con 3 decimales significativos de la marena siguiente: (ar / long) :0:3 .Con lo descrito anteriormente el programa nos pide que ingresemos el radio de una circunferencia y seguidamente nos calcula el área y la longiud.

Esquema del programa

Progam Circle;Uses crt;

29

Const pi=3.1415926;Var ra, long, ar: real;

Beginclrscr; Writeln(‘ X ’);Writeln();Write(‘ X ’);Writeln();Readln(ra);Ar:=pi*ra*ra;Write(‘ X ’,ar:0:3);Writeln();Long:=2*pi*ra;Write(‘ X ’,long:0:3);readkey;

End.

3.5 Positivo

Empezamos nombrando el programa como queramos, en este caso se llamará Positivo.Declaramos la biblioteca que vamos a utilizar, crt.Declaramos las variables a utilizar: num de tipo: integer.Escribimos en pantalla que el usuario nos ingrese un número.Con un readln el programa lee el número. Seguidamente imponemos una condicion, en este caso utilizamos el “If” una sentencia que lo que hace es: si la variable introducida cumple la condición, haga una cosa (If X <,>,<=,>= etc Y then) y si no, que haga la otra (else).En este caso imponemos que si la variable num es >0 que nos escriba por pantalla que el número es positivo; si el número introducido nos

30

es >0 entonces el programa nos escribe que el número es 0 o negati-vo.Con todo lo destrito anteriormente le programa nos pide que ingrese-mos un numero y nos dira si es positivo o negativo.

Estructura del programa

Progam Positivo;Uses crt;Var num: integer;

Beginclrscr; Write(‘ X ’);Readln(num); If num>0 then Writeln(‘ X ’); else Write(‘ X ’);readkey;

End.

3.6 Vectores

Empezamos nombrando el programa como queramos, en este

caso se llamará Positivo.Declaramos la biblioteca que vamos a utilizar, crt.

31

Declaramos las variables a utilizar: vac: array[1..5] of real (hemos de-clarado un vector de longitud 5) y n1, n2: real.Escribimos por pantalla lo que el programa nos va a hacer, en este caso hacer la media de un vector de 5 elementos.Introducimos los 5 elementos, a la hora de escribir el read tenemos que especificarle que el valor introducido es 1 de los 5 elementos de la variable vec, se especifica de la siguiente manera Readln(vec[1]), Readln(vec[2]), Readln(vec[3]) hasta 5.Despues de introducir los 5 elementos del vector, a la variable n1 le asigamos la suma de los 5 elementos (vec[1]+vec[2]+vec[3]+vec[4]+vec[5]) y a la variable n2:= n1/5 (la media de la suma de los elementos vectoriales).Despues sacamos por pantalla el resultado de la suma vectorial(n1) con extensión “:0:2” y hacemos lo mismo con la media(n2) tambien con extensión “:0:2”.Con todo lo descrito anteriormente, el programa nos pide que intro-duzcamos 5 elementos de un vector y posteriormente nos calculara la suma vertorial y la media.

Estructura del programa

Program MediadleVector: Uses crt; Var vec: array[1..5] of real; n1, n2 :real;Begin

clrscr;Write(‘ X ’);Write(‘ X ’);Realln(vec[1]);Write(‘ X ’);Realln(vec[2]);Write(‘ X ’);Realln(vec[3]);Write(‘ X ’);Realln(vec[4]);Write(‘ X ’);Realln(vec[5]);n1:=vec[1]+ vec[2]+ vec[3]+ vec[4]+ vec[5];n2:=n1/5Wrtieln(‘ X ’,n1:0:2);Writeln(‘ X ’,n2:0:2);Readkey;

End.

3.7 Saludo 2

32

Empezamos nombrando el programa como queramos, en este caso se llamará Saludo2.Declaramos la biblioteca que vamos a utilizar, crt.Declaramos las variables a utilizar: nombre: ansistring (definimos una cadena de caracteres de longitud variable) y edad: integer.Empezamos con un write donde nos pregunta por nuestro nombre, lo introducimos y lo lee mediante un readln.Seguidamente con otro write nos muestra en pantalla: Hola , nombre, Como estas?, esto se hace de la siguiente manera _Writeln(‘!Hola¡’, variable nombre,’ ¿Cómo estas?’);_Luego hacemos lo mismo con la variable edad, nos la puide, la intro-ducimos, la lee y en el siguiente read la incluimos para que nos la muestre por pantalla.Con todo lo descrito anteriormente, el programa nos piede nuestro nombre y nuestra edad para luego entablar una “conversación prede-finida” con nuestros datos introducidos.

Estructura del programa

Program Saludo2; Uses crt; Var

nombre: ansistring;edad: integer;

Beginclrsrc;Write(‘ X ’);Readln(nombre);Writeln(‘ X ’,nombre, ‘ X ’);Writeln(‘ X ’);Readln(edad);

33

Writeln(‘ X ’,edad);Readkey;

End.

3.8 Concatenar

Empezamos nombrando el programa como queramos, en este caso se llamará Concatenar.Declaramos la biblioteca que vamos a utilizar, crt.Declaramos las variables a utilizar: t1, t2, sum :ansistring.Empezamos con un write donde nos pida que estribamos un texto, se-guidamente un readln lo lee y otro write nos vuelve a pedir un 2º tex-to con si correspondiente read.Despues haber introducido los 2 textos a la variable sum se le asigna la suma de t1+t2.Mediante la funcion Gotoxy (una funcion que nos permite llevar lo que queremos que salga en pantalla a unas coordenadas del eje carteiano concretas) en este caso queremos llevarlo a la posición (15,9) y lo ha-cemos de la siguiente manera Gotoxy(15,9).Una ves escrito la funcion goto, escribimos un write para que nos muestre los dos textos juntos y en las coordenadas (15,9).Con todo lo descrito anteriormente, el programa nos pide que escriba-mos 2 textos y posteriormente los junta y los lleva a una posición de-terminada del la pantalla.

Estructura del programa

Program Concatenar; Uses crt; Var

34

t1, t2, sumv: ansistring;Begin

clrsrc;Write(‘ X ’);Read(t1);Write(‘ X ’);Read(t2);Sum:=t1+t2:Gotoxy(15,9);Write(sum);Readkey;

End.

3.9 Azar

Hemos creado un programa que te dice numero de la loeteria.Para ello hemos tenido que introducir la función randomize y después num:=random(100) para que nos sacara número al azar entre 0 y 100. El resto del programa es lo normal, lo de siempre. Writeln para el pro-grama pida algo, y readln para que el programa lo identifique y lo ex-ponga después junto con la variable que le he asignado, que en este caso ha sido real (números reales).

Estructura del programa

Program Concatenar; Uses crt; Var

Nom, num1,num2,num3, num4, num5, num6 :interger;

Beginclrsrc;Write(‘ X ’);Readln(nom);Writeln(‘ X ’);

35

Writeln();Randomize;num1:=random(49)+1;Writeln(‘ X ’,num1);num2:=random(49)+1;Writeln(‘ X ’,num2);Num3:=random(49)+1;Writeln(‘ X ’,num3);Readkey;

End.

3.10 Redondeo

En este ejercicio hemos hecho que el programa nos pida un nú-mero entero y después nos ponga su valor original, su valor truncado, su valor redondeado. Después nos sume, multiplique y divida con otro número del mismo tipo de variable, y pidiéndonos dos números reales nos de la diferencia entre ambos, una división normal, otra donde después le pedimos el resto y te lo da y el opuesto de unos de ellos.

36

Para ello primero hemos pedido una variable real con los dos prime-ros números. Con el primer número, mediante las funciones round y trunc hemos conseguido redondearlo y que el programa nos de su va-lor así y truncarlo. - antes de eso hemos añadido la función formato para así poner los decimales que queramos y lo hemos hecho ponien-do el número y :0:2 siendo el segundo número el número de decima-les que hemos querido que tuviera.Después hemos ingresado el otro número y mediando writeln hemos hecho la suma, el producto y la división. Todo esto añadiendo la fun-ción de formato, pues son números reales y si queremos que salga un determinado número de decimales hay que ponerlo.A continuación hemos introducido dos números enteros con la varia-ble integer y los hemos ido dividiendo y demás como antes he dicho y el programa después nos da esos valores. Aquí no se pone la función formato.

3.11 Mayor de edad

El siguiente ejemplo consiste en que el programa pide el nom-bre, la edad y después te dice cómo te llamas y si eres mayor de edad o no.Respecto a lo de pedir el nombre y la edad lo hemos hecho como siempre, con un writeln.Después para decir si la persona es mayor de edad o no, hemos utili-zado la función if / else. Hemos puesto if K<18 k="">18 te diga que eres mayor de edad.

37

Los dos procesos de que si eres o no mayor de edad según sea K hay que ponerlos con un begin y un end para que el programa lo realice después correctamente.

3.12 Contraseña

Este ejercicio consiste en que el programa te pide el nombre de usuario, si es Juan que pida una contraseña, y si no es Juan que salga que el programa se autodestruiría en 10 segundos. Y después si se in-troduce el nombre de usuario correcto que te pide la contraseña de cuatro dígitos y si lo haces bien sale por la pantalla bienvenido y si no que la contraseña es incorrecta.Todo esto se ha hecho con la función if / else.

3.13 Cadenas

38

El funcionamiento de este programa es sencillo.Mediante la funcion “length” podemos contar cuantos caracteres he-mos escrito (contando los espacios).Este son los pasos:Nos sale en pantalla que escribamos nuestros nombre.Con un read lo lee y en el write donde nos diga cuandos caracteres tiene nuestro nombre incluimos la funcion length de la siguiente ma-nera:

Write(‘Tu nombre completo tiene : ‘, length(nom)’letras’);.

Estructura del programa

BeginClrscr;Writeln(‘ X ’);Read(nom);Write(‘ X ’, length(nom),’ X ’);Readkey;

End.

3.14 Sentencia For

39

La sentencia for nos permite que desde un intervalo numerico haga una cosa y cuando llege al final podemos decirle que haga lo contra-rio a lo anterior con un dowto.El programa que hemos tomado como ejemplo es que la funcion nos muestre por pantalla numeros del 1 al 10 y que cuando llege al 10 que lo haga de manera viceversa, del 10 al 1.Tambien hemos tenido que usar un Begin dentro de otro debido a que dentro de un for solo puede haber escrito una linea de programa pero si dentro del for empezamos un begin podemos escribir tantas lineas de programa como queramos.La funcion downto es la mencionada anteriormente (desde 10 has-ta1).

3.15 Letra

ç

Mediante este programa podemos averiguar el codigo Ascii.

40

En este caso hemos averiguado el codigo Ascii de las letras desde la a hasta la z (mayusculas y minusculas).Todo esto lo hemos hecho con la funcion chr y la funcion ord.

41