¡Descarga APRENDER DESDE CERO PASCAL y más Guías, Proyectos, Investigaciones en PDF de Programación Funcional solo en Docsity!
Capítulo 1º
Notas
Introdución
Principal
Capítulo 2º
Capítulo 3º
Capítulo 4º
Capítulo 5º
Capítulo 6º
Capítulo 7º
Capítulo 8º
ESTRUCTURA DE UN PROGRAMA EN PASCAL
Hecha la introdución ahora empezaremos a meternos en materia. Esta vez ya atacamos fuerte y nos metemos con cómo se "monta" un programa en Pascal.
Al Pascal no se le llama programación estructurada porque sí. A la hora de ponerse a hacer un programa hay que seguir una estructura bastante estricta.
El esquema general de un programa sería este:
- Nombre del programa
- USES
- Definición de tipos globales
- Definición de constantes globales
- Definición de variables globales
- Procedimientos
- Declaración
- Tipos locales
- Constantes locales
- Variables locales
- Codigo del procedimiento
- Código principal
Así al principio puede parecer mucha cosa, pero si os digo que por muy complicado que sea el programa que hagais NUNCA vais a usar más elementos de los que he puesto aquí... ¿entonces qué? ;) Lo que sí que podremos usar, sobretodo al principio, son menos elementos.
Por ahora veamos por partes en qué consiste cada "trozo" de programa.
NOMBRE DEL PROGRAMA
Pues algo tan tonto como lo que podeis estar pensando. Consiste en darle un nombre al programa. Se hace poniendo al principio del programa una linea como esta:
Program Programa_Que_Dice_Hola;
"Program" es una palabra reservada del Pascal que sirve para indicar que a continuación ponemos el nombre del programa.
El nombre del programa NO puede contener espacios ni algunos otros caracteres "raros" como, por ejemplo, la "Ñ".
El punto y coma final es IMPRESCINDIBLE. En Pascal ese punto y como se pone como "separador" de instruciones. Así, después de cada instrución pondremos un punto y coma. Ya lo iremos viendo.
USES
Uses es la palabra reservada de Pascal para incluir librerías. Como ya he dicho antes, una librería no es más que un conjunto de funciones, que nosotros mismo podemos hacernos. Cualquier compilador de Pascal viene con unas librerías standar que traen funciones para trabajar con archivos, memoria, directorios, servicios del Dos, servicios de video, etc...
Sin esas librerías no podríamos hacer prácticamente nada. Siempre podríamos hacernoslas nosotros, pero sería un trabajo inmenso.
De entre todas las librerías del Pascal hay una que es especial, la librería SYSTEM.TPU. Es especial porque contiene las funciones más básicas, como pueden ser las que nos sirven para escribir en la pantalla, y esta librería se incluye SIEMPRE en nuestros programas.
Otras librerías muy utilizadas con CRT.TPU, DOS.TPU y GRAPH.TPU, por ejemplo, pero de esto ya nos encargaremos cuando hablemos específicamente de las librerías.
Para incluir una o varias librerías hay que añadir una linea de este estilo al programa:
USES Crt, Dos, Graph;
DEFINICION DE TIPOS GLOBALES
En esta seción de declaran las estructuras globales que vamos a utilizar. Se les llama globales porque las estructuras que definamos aquí podrán ser utilizadas en cualquier punto del programa. Los tipos de datos son una de las cosas completas de Pascal, hablaremos de ellos en la próxima entrega. ;)
DEFINICION DE CONSTANTES GLOBALES y
DEFINICION DE VARIABLES GLOBALES
De las constantes y las variables hablaremos en el próximo capítulo. ;)
PROCEDIMIENTOS
Un procedimiento podríamos definirlo como un trozo de programa "autónomo". Es lo que antes he llamado una función. Las librerías están llenas de pedazos de programa autónomos de estos. ;)
Aunque en un principio puede parecer una chorrada tener que ir partiendo los programa en procedimientos, esto resulta muy útil para hacer un programa. Para dejarlo claro pondré un ejemplo sencillo:
Pongamos que tenemos que hacer un programa que dibuje muchos cuadrados. Cada cuadrado se dibuja a base de 4 lineas. Y cada linea se dibuja a base de muchos puntos colocados en linea.
Podríamos hacer un programa como este:
Dibujar_Punto en 0,
Procedure Escribe_Texto; { Declaración del procedimiento } Begin WriteLn(Texto); { escribe la constante "Texto" } End;
Begin { inicio del código principal } Escribe_Texto; { llamada al procedimiento } End.
Y esto es todo por hoy. En la próxima entrega nos empezaremos a meter con las variables, las contastes, los tipos y las estructuras de datos, que ya empieza a ser un plato fuerte. Por hoy ya sólo queda el mini- glosario que incluiré en todos los faSículos que crea que tienen palabras que necesitan explicación. ;)
GLOSARIO:
- Palabra reservada: como su nombre indica, es una palabra que en un determinado lenguaje ha sido reservada para realizar una función concreta. Una palabra reservada sólo puede ser usada para la finalidad que se le da en el lenguaje en cuestión y usarla de otro modo (intentando declararla como variable o como procedimiento, por ejemplo) dará un error de compilación.
En el próximo capítulo hablaremos de las variables que se utilizan para trabajar con ficheros y de las variables "compuestas".
por ComaC
Cursillo de Pascal por ComaC -- Introdución
Capítulo 0º
Notas
Principal
Capítulo 1º
Capítulo 2º
Capítulo 3º
Capítulo 4º
Capítulo 5º
Capítulo 6º
Capítulo 7º
Capítulo 8º
Introdución
Venga! Tal y como prometí aquí está la primera entrega del curso de
Pascal. Ya que es el primer faSículo y dado que estamos en exámenes,
empezaré flojito. Por hoy sólo definiremos algunos conceptos y
daremos una introdución a lo que es el Pascal.
Algunas cosas antes de empezar:
1º Si alguien tiene pensado guardar los mensajes del cursillo para
luego subirlo a la BBS o para tenerlo guardado, que no lo haga,
porque ya lo haré yo mismo. (y según como incluiré también imágenes
para aclarar algunas cosas o alguna otra cosa interesante)
2º El cursillo consiste en: yo pongo un mensaje, tú te lo lees y lo
aprendes. Pero no me gustaría que se limitara sólo a eso. Yo NO voy a
proponer ningún problema para que lo resolvais ni voy a proponer
ningún exámen. Si quereis algo de este estilo lo teneis que pedir.
Estoy abierto a cualquier tipo de actividad que ayude a entender y
asimilar el cursillo, pero teneis que ser vosotros los que lo pidais. (Si
quereis hacer algo pero no sabeis qué, pues me lo deciis y ya os
propondré algo)
Creo que con esto ya he dicho todo lo que quería decir antes de
comenzar. Así que EMPEZAMOS!!!
CAPITULO 0º: Introdución
Este capítulo no contiene nada especialmente importante. Mi
recomendación es que lo leais 2 o 3 veces, que lo entendais bien y que
os quedeis con una visión global de lo que es el Pascal, lo que es un
Compilador, etc... No os fijeis en los detalles sino sólo en lo más
general.
TÉRMINOS QUE VAMOS A USAR
file:///C|/Documents%20and%20Settings/gabri/Escritorio/pascal/intro.htm (1 de 4) [12/10/2002 23:13:23]
Cursillo de Pascal por ComaC -- Introdución
Escribías el programa, salias del editor, compilabas, lo probabas y
volvías al editor para continuar. Ya que eso era un tanto engorroso
aparecieron los IDE. (aunque yo para programa en ASM lo sigo
haciendo de esta manera :m) El IDE es un programa que sirve de
editor, compilador y depurador a la vez. Además de traer un sistema
de ayuda muy útil y otras tantas cosas. De esta manera es mucho más
cómodo programar. Podemos hacerto todo desde el IDE. En nuestro
caso, el IDE es lo que nos aparece al ejecutar el TURBO.EXE. ;) El
Turbo Pascal también tiene un compilador "a la antigua" o, como
debería decirse, un compilador desde la linea de comandos. El
TPC.EXE. Para compilar el programa HOLA.PAS escribiríamos: "TPC
HOLA.PAS"
INTRODUCION AL PASCAL
El Pascal es un lenguaje de propósito general. Esto quiere decir que
sirve para cualquier cosa. En contraposición a lenguajes como
CLIPPER, que está orientado principalmente al manejo de bases de
datos.
También es un lenguaje de programación estructurada. Esto quiere
decir que en Pascal no podemos poner las cosas como nos dé la gana
y dónde nos dé la gana, sino que tenemos que seguir algunas reglas.
Al principio puede parecer imposible programar siguiendo estas
reglas, pero una vez acostumbrados vereis que es mejor programar
así.
Los elementos más importantes de la programación estructurada son
las variables y los procedimientos. Las variables tienen que definirse
antes de usarse (cosa que no era necesario en BASIC) y además
hemos de decir de qué tipo van a ser. En BASIC, por ejemplo,
podemos poner en cualquier punto del programa una instrución del
tipo "A = 2" y le asignaremos a la variable A el valor 2, sin importarnos
si la variable A es de 8 bits o de 16 o con signo o sin signo. (Si no
consigues acabar de entender esto no te preocupes, de las variables
ya hablaremos detenidamente cuando llegue si momento ;)
El otro elemento he dicho que eran los procedimientos. ¿Qué es un
procedimiento? Respuesta fácil y sencilla: un pedazo de código. Al
principio puede parecernos incómodo tener que partir un programa en
cachos en vez de ponerlo todo seguido, tal y como podría hacerse en
BASIC, pero en cuanto veamos algún ejemplo os dareis cuenta de que
es muy práctico. Realmente un procedimiento es bastante más
completo que "un pedazo de código", pero por ahora estamos en la
introdución y lo que interesa es que saqueis una visión global de lo
que es el pascal. Cuando vayamos pasando por cada uno de los
puntos en cuestión ya veremos las cosas con todos sus detalles.
Para acabar, me queda decir que a la programación estructurada
también se la llama "programación sin GOTO". Y esto es porque NO se
usa NUNCA dicha instrución. A los que hayais programado en BASIC
tal vez os parezca imposible programar sin esa instrución (tal y como
file:///C|/Documents%20and%20Settings/gabri/Escritorio/pascal/intro.htm (3 de 4) [12/10/2002 23:13:23]
Cursillo de Pascal por ComaC -- Introdución
pensé yo) pero no es nada difícil. Para suplir el GOTO tenemos la
estructuración de los procedimientos y diferentes bucles iterativos.
(cosas que explicaré en su momento)
El Turbo Pascal incluye la función GOTO y puede utilizarse, pero yo no
la voy a explicar. Al menos no hasta el final del curso.
Y esto es todo por hoy. El próximo lunes más. ;)
Empezaremos con la estructura general de un programa en Pascal y
hablaremos un poco a cerca de las librerías básicas.
Cualquier duda o sujerencia que tengais podeis preguntármela por el
area. (con lo de sujerencia me refiero a si quereis problemas para
prácticar (aunque por ahora todabía no podemos) o cualquier otra
cosa)
por ComaC
file:///C|/Documents%20and%20Settings/gabri/Escritorio/pascal/intro.htm (4 de 4) [12/10/2002 23:13:23]
WORD (16 bits, 0..65535)
Define una variable de 16 bits que soporta valores de 0 a 65535.
LONGINT (32 bits, -2Gb..(2Gb-1) )
Define una variable de 32 bits (4 bytes) que puede contener valores desde - hasta 2147483647.
REAL, SINGLE, DOUBLE (punto flotante)
Estos tipos son también numéricos pero son un tanto peculiares. Están pensados para poder trabajar con números muy grandes pero no tienen mucha precisión, es decir 4+1 no siempre será 5. Una característica de estos tipos de datos, además de poder trabajar con números de hasta 1.1e4932, es que con ellos podemos usar números con decimales. A una variable SINGLE le podemos asignar el valor 1.5 (y tal vez lo que se guarde realmente sea 1.49, como ya he dicho) pero en cambio no le podemos asignar ese mismo valor a una variable de tipo INTEGER, por ejemplo.
Las operaciones con los tipos SINGLE y DOUBLE se realizarán bastante más rápido si se ejecutan en un ordenador con coprocesador matemático y se ha activado la opción del compilador para usarlo. Los REAL en cambio no irán más rápido ya que no son un formato standar sino que es un formato que se ha inventado Borland para sus compiladores de Pascal.
STRING (cadena)
Define una variable de 256 bytes que puede contener una cadena de hasta 255 caracteres. (Una frase de hasta 255 letras, para entendernos ;)
PUNTEROS
Los punteros los trataremos más adelante en un capítulo que ellos solos, ya que es un tema muy extenso. Por ahora prescindiremos de ellos.
Por hoy ya está. Este es uno de los capítulos que convendría imprimirlos y tenerlos delante de las narices a la hora de hacer prácticas. Para acabar os pongo un ejemplo para que veais cómo se declararían y usarían las variables de cada tipo, aunque para entender bien el programa hacen falta los capítulos sobre asignaciones y sobre funciones de librería, pero para hacerse una idea yo creo qye ya irá bien. ;)
Program Programa_Demo_De_Variables;
Const { Definimos constantes, como ya habíamos visto } Numero = 8; Cadena = 'Esto es una cadena ;)';
Var { Declaramos unas cuantas variables... } Tipo_Int : Integer; { Usamos el Integer como ejemplo para: BYTE, SHORTINT, INTEGER ,WORD y LONGINT } Tipo_Bool : Boolean;
Tipo_Real : Single; { Usamos el tipo SINGLE como ejemplo para: REAL, SINGLE y DOUBLE } Tipo_Char : Char;
Tipo_Cad : String;
Begin Tipo_Int := Numero; { Asignamos el valor 8 a Tipo_Int } WriteLn(Tipo_Int); { Sacamos por pantalla el contenido de Tipo_Int }
Tipo_Int := 4; { Asignamos el valor 4 a Tipo_Int } WriteLn(Tipo_Int); { Sacamos por pantalla el contenido de Tipo_Int }
Tipo_Bool := True; { Asignamos el valor True a Tipo_Bool } WriteLn(Tipo_Bool); { Sacamos por pantalla el contenido de Tipo_Bool }
Tipo_Real := 87.724; { Asignamos el valor 87.724 a Tipo_Real } WriteLn(Tipo_Real:0:3);{ Sacamos por pantalla el contenido de Tipo_Real }
Tipo_Char := 'A'; { Asignamos la letra 'A' a Tipo_Char } WriteLn(Tipo_Char); { Sacamos por pantalla el contenido de Tipo_Char }
Tipo_Cad := Cadena; { Asignamos "Esto es una cadena ;)" a Tipo_Cad } WriteLn(Tipo_Cad); { Sacamos por pantalla el contenido de Tipo_Cad }
End.
En el próximo capítulo hablaremos de las variables que se utilizan para trabajar con ficheros y de las variables "compuestas".
por ComaC
Pero también podemos definir un array como el siguiente:
Tabla : Array [1..10,1..10] of Byte;
En este caso se dice que tenemos un array bidimensional. Esto és: ahora el array ya no se representaría como un fila sino como una tabla de 10 filas y 10 columnas. Así:
De esta forma, con Tabla[5,2] nos estaríamos refiriendo al elemento que he marcado con "YY" y con Tabla[3,6] nos referiríamos al elemento marcado con "XX".
También pueden hacerse array de más dimensiones símplemente añadiendo el tamaño de la nueva dimensión mediante comas. Para un array de 3 dimensiones lo declararíamos así:
Tabla3D : Array [1..10,1..10,1..10] of Word;
ESTRUCTURAS
Una estructura define una variable formada por varios campos, y cada campo puede ser de un tipo diferente. Por ejemplo, pongamos que en una variable queremos guardar los datos de un amigo. Podríamos definir una estructura como esta:
Var Amigo : Record Nombre : String; Edad : Byte; DNI : Longint; Telefono : Longint;
End;
Con esto declaramos la variable amigo, que tiene 4 campos. El campo Nombre es una cadena de caracteres (String) el campo Edad puede contener valores de 0 a 255 y los campos DNI y Telefono son Longint para poder almacenar números grandes.
Para acceder a los campos lo hacemos escribiendo su nombre tras el de la variable separando ambos mediante un punto. Para rellenar la estructura podríamos hacer:
Amigo.Nombre := 'Perico el de los palotes'; Amigo.Edad := 29; Amigo.DNI := 12345; Amigo.Telefono := 3589325;
En las estructuras podemos incluir CUALQUIER tipo de datos. Incluidos los arrays e incluso otras estructuras. Así, podemos declarar una variable con:
Amigo_Cambia_Cromos : Record Nombre : String; Edad : Byte; Tengui : Array [1..300] of Word; Falti : Array [1..300] of Word; Colecs : Record BolaDeDrac : Boolean; SonGoku : Boolean; DragonBall : Boolean; End; End;
De esta manera, en Amigo_Cambia_Cromos.Tengui[20] guardaríamos si el amigo tiene o no el cromo 20, y en Amigo_Cambia_Cromos.Colecs.SonGoku pondríamos TRUE o FALSE dependiendo de si tiene hecha la coleción de cromos del Goku o no.
Y más útil todabía es poder definir una estructura dentro de un array. Es decir, algo como esto:
Amigos : Array [1..100] of Record Nombre : String; Edad : Byte; Colecs : Record SonGoku : Array [1..300] of Boolean; BulmaEnBolas : Array [1..300] of Boolean; End; End;
Con esto, definimos una "lista" en la que podemos guardar los datos de 100 amigos diferentes. Podemos guardar su Nombre, su Edad y los cromos que tienen de las dos coleciones.
TIPOS DE DATOS
Para acabar con las estructuras veremos cómo se define un tipo de datos. Los tipos de datos se definen a continuación de la palabra reservada "Type". (al igual que las variables bajo "Var" o las constantes bajo "Const") Y a un tipo que nosotros definamos le podemos asignar cualquier tipo de variable de los que hemos visto. Definir el tipo siguiente, por
ahora resulta que sólo puedo usar 64 Kbs? Bueno, para algo están las variables dinámicas.
VARIABLES DINAMICAS
Las variables dinámicas son, para decirlo de manera simple, los punteros. La memoria que necesita un puntero no se reserva desde el comienzo del programa sino que seremos nosotros quienes decidiremos cuándo ha de asignarse memoria a un determinado puntero. (También deberemos acordarnos de liberarla una vez hayamos terminado)
Además, la memoria para los punteros no se saca del segmento de datos sino que se saca de la memoria que quede libre después de cargar el programa. Si usamos un compilador para modo real, podremos usar lo que quede de memoria hasta los 640 Kbs, y si usamos un compilador para modo protegido podremos usar toda la memoria que quede libre hasta el final de ésta. (que pueden ser 4, 8, 16... la Ram que tengamos) Como ejemplo en el cursillo usaremos un compilador en modo real (El Turbo Pascal 7)
Cada puntero tiene su propio segmento, por lo tanto a un puntero no le podremos asignar más de 64Kbs de memoria, pero como no es necesario que los punteros tengan el mismo segmento, podemos usar toda la memoria que quede libre a base de asignar una parte a varios punteros. Esto es un tema complicado que trataremos en el capítulo sobre punteros.
Espero no haberos liado demasiado con esta explicación sobre los arrays, las estructuras, las variables estáticas y las dinámicas. Si algo no se entiende no teneis más que preguntarme, claro está. ;) Ahora ya sólo nos quedan 2 capítulos para poder hacer un programa completo.
por ComaC
Capítulo 4º
Notas
Introdución
Capítulo 1º
Capítulo 2º
Capítulo 3º
Principal
Capítulo 5º
Capítulo 6º
Capítulo 7º
Capítulo 8º
EXPRESIONES
Bueno... antes de nada esta vez quiero decir que he estado a punto de cargarme el HD enterito y que hace poco me cargué más de la mitad de la base de mensajes. Con lo cual he perdido todos los mensajes sobre el cursillo y el índice que tenía hecho. Pero por suerte, todabía tengo un montón de hojas sueltas en las que tengo todos los esquemas que me planteé antes de empezar así que por ahora parece que pese a todo podré continuar. O:)
Hoy nos toca hablar sobre las expresiones. Es un asunto sencillo pero que es importante que quede claro. Una expresión, para decirlo de manera sencilla, podríamos decir que es un cálculo. Por ejemplo, una expresión podría ser esto: (7+815-34)/*
Puesto que es un cálculo podemos indicar operaciones. Tenemos dos tipos de operaciones las numéricas y las lógicas. Las numéricas las realizamos con números y dan como resultado un número. Las lógicas las podemos realizar con números o con valores booleanos y dan como resultado un valor booleano.
OPERACIONES NUMERICAS
Empecemos por las numéricas. Como operaciones
numéricas tenemos estas:
+ : Suma.
**- : Resta.
- : Producto. % : Módulo. (es decir, haya el resto de la división) EJ: 4 % 3. Da el resto de 4 / 3, que es 1.**
/ : División de reales. Esta división da como resultado un número real. Acepta como operandos tantos números reales como enteros.
Div : División de enteros. Esta división da como resultado un número entero y no acepta como operandos números reales.
Los operandos que podemos utilizar son: valores
inmediatos, constantes o variables. Por ejemplo, en
este caso:
Const Constante = 7;
Var Tabla : Array [0..10] of Byte; A : Word;
Begin A := 8 + Tabla[9] - Constante; End.
devolverá falso, pero la expresión "A = 2"
tal vez devuelva falso o tal vez devuelva
verdadero, ya que dependerá de si la
variable A está almacenando o no el valor
2 en el momento en que se hace la
comprobación.
Como siempre, podemos complicar las cosas
y escribir cosas como esto:
(Tabla[3] - Constante + 8 * Tabla[ Tabla[ 9 - 3 ] + 9) >= Tabla[5]
(Si alguien no acaba de ver claro esto, que pruebe a desglosar en pasos esta expresión, tal y como he hecho yo con las anteriores, y me lo comente)
Las 3 últimas operaciones de la lista ya no trabajan con expresiones numéricas sino con expresiones lógicas. Teniendo arriba la función de cada una creo que lo mejor es explicarlo mediante ejemplos.
(3 = 2) or (1 = 4) daría siempre falso porque la expresión (3 = 2) da falso y la expresión (1 = 4) también. Y "or" sólo devuelve verdadero cuando al menos una de las expresiones es verdadera.
(3 = 2) or (1 = 1) daría verdadero porque aunque (3 = 2) es falso, (1 =
- es verdadero.
((3 = 2) or (1 = 1)) and (9 = 3) devolvería falso porque ((3=2) or (1=1)) da verdadero pero (9 = 3) da falso. Y para que "and" devuelva verdadero han de ser verdaderas las dos expresiones.
not (1=3) daría verdadero. Porque (1=3) da falso y "not" devuelve lo contrario de lo que vale la expresión dada.
Hasta aquí es sencillo, pero hay que tener en cuenta que no nos vamos a limitar a hacer que el Turbo Pascal nos diga que 1 no es igual a 3. La finalidad de esto es mucho más útil, por supuesto. Hay que recordar que para construir las expresiones lógicas podemos valernos de cualquier expresión numérica. Esto es, si tenemos dos expresiones numéricas como estas:
(Tabla[4] - 8) * 34 (Contante + A) % Tabla[3]
Podemos hacer una expresión lógica que compare esas dos expresiones, como por ejemplo:
( (Tabla[4] - 8) * 34 ) >= ( (Constante + A) % Tabla[3] )
Y una vez tenemos esta expresión lógica podemos combinarla con otras expresiones lógicas para hacer expresiones lógicas más complejas, por ejemplo algo como esto:
((( Tabla[4] - 8) * 34 ) >= ((Constante + A) % Tabla[3])) or (2=(1+A))
(si alguien quiere entretenerse, podría ser un buen ejercicio calcular para qué valores de Tabla[4], Tabla[3] y A la expresión ENTERA es
verdadera.
Uhm... creo que por hoy no tenía que decir nada más. :m ... Tampoco os puedo asegurar que aquí esté todo lo que tenía que decir, porque he perdido los esquemas, pero... bueno... creo que sí. O:)
por ComaC
