VARIABLES (2ª PARTE) CAPITULO-3
En el último capítulo empezamos a explicar los tipos básicos de variables.
En este seguimos con las variables para control de archivos y los tipos
compuestos.
TEXT
Una variable de tipo TEXT declara una variable que servirá para contener
los datos de un archivo. Esos datos los necesita el programa para controlar el
archivo, pero nosotros nunca los trataremos. Las funciones de la librería se
encargan de modificar/tratar todo lo necesario en este tipo de variables. Así, por
ejemplo, al llamar a la función Reset, ésta rellenará la variable que le
indiquemos con los datos del archivo que hemos abierto.
Las variables TEXT sirven para trabajar con archivo de texto. Todo lo
referente a la gestión de archivos lo trataremos más adelante, cuando hablemos
de las funciones de la librería para trabajar con archivos.
FILE
Una variable de tipo FILE tiene exactamente la misma función que una TEXT
sólo que en vez de tratarse de archivos de texto nos permitirá trabajar con
archivo binarios. Podemos definir variables FILE de varios tipos, dependiendo
del tipo de elementos que integren el archivo o incluso podemos definir una variable
FILE sin tipo, pero esto, como ya he dicho, lo trataremos más adelante.
ARRAY
Define una variable que es un conjunto de elementos de un tipo. Es decir,
si definimos un array de CHARs, por ejemplo, la variable en cuestión no
contendrá un solo elemento de tipo CHAR sino varios, la cantidad que nosotros
le indiquemos. Pongamos un ejemplo:
Var
Grupo : Array [1..10] of Integer
Este código define la variable Grupo como un array que contiene 10 datos de
tipo Integer. Para acceder a uno de esos datos lo hacemos indicando el número
de orden entre corchetes. Así, para acceder al dato nº 6 haríamos esto:
Grupo[6] := 9;
O para asignar a el elemento nº 6 el mismo valor que el elemento 9 podemos
hacer esto:
Grupo[6] := Grupo[9];
Podemos imaginarnos un ARRAY como una fila de elementos del tipo que hemos
especificado. El array de la variable Grupo sería esto:
Nro de Orden
|
1
|
2
|
3
|
4
|
5
|
6
|
7
|
8
|
9
|
10
|
Elemento
|
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í:
1
|
2
|
3
|
4
|
5
|
6
|
7
|
8
|
9
|
10
|
2
|
|||||||||
3
|
xx
|
||||||||
4
|
|||||||||
5
|
xx
|
||||||||
6
|
|||||||||
7
|
|||||||||
8
|
|||||||||
9
|
|||||||||
10
|
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 simplemente 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 Teléfono 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 colecciones.
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 ejemplo, no
tiene gran utilidad:
Type
Octeto = Byte;
Con él podríamos definir una variable como esta:
Var
Edad : Octeto;
Y sería equivalente a escribir:
Edad : Byte;
Pero cuando se trata de estructuras esto sí que puede ser muy útil, sobre
todo para crear un código claro y legible. Podemos definir un tipo que contenga
la estructura que queramos y a partir de entonces trabajar con ese tipo de
datos. Por ejemplo:
Type
Estructura = Record
Nombre : String;
Edad : Byte;
End;
Var
Variable1 : Estructura;
Variable2 : Array [1..10] of Estructura;
OTROS
Existen más tipos de datos (el PChar, por ejemplo) pero de momento no los
explicaré porque o bien no son básicos o bien están incluidos en el Turbo
Pascal por motivos de compatibilidad.
VARIABLES
ESTATICAS
Todas las variables que hemos visto hasta ahora son variables estáticas. Esto
quiere decir que las variables existen ya al empezar el programa y no cambian
durante la ejecución de este. Podemos cambiar el contenido de las variables, pero
no podremos cambiar el tamaño ni el tipo ni nada de eso.
Estas variables se almacenan en una zona reservada para datos. En el segmento
de datos, concretamente. No entraré en la explicación de lo que es un segmento,
pero en un segmento sólo caben 64 Kbs. (que son 65536 bytes y NO 64000 bytes)
Por lo tanto, si escribimos una declaración de variables como esta, el
compilador nos dará un error:
Var
Tabla1 : Array [1..40000] of Byte;
Tabla2 : Array [1..40000] of Byte;
¿Por qué da el error? Pues porque para almacenar todas esas variables necesitamos
80000 bytes, que son más de los 65536 que nos proporciona el segmento de datos.
Entonces ¿sólo podemos usar 64 Kbs de memoria en Pascal? ¿Qué pasa con las 32
megas de Ram que tiene tal ordenador? ¿Para qué me mato yo en conseguir liberar
630 Kbs de memoria convencional si 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.
DESCARGAR CAPITULO 3 VERSIÓN PDF
CAPITULO 4
0 comentarios: