Tema 7: Constantes y tipos.

Cuando desarrollamos un programa, nos podemos encontrar con que hay variables que realmente "no varían" a lo largo de la ejecución de un programa, sino que su valor es constante.

Hay una manera especial de definirlas, que es con el especificador "const", que tiene el formato

const Nombre = Valor;

Veamos un par de ejemplos antes de seguir

const MiNombre = 'Nacho Cabanes';
const PI = 3.1415926535;
const LongitudMaxima = 128;

Estas constantes se manejan igual que variables como las que habíamos visto hasta hora, sólo que no se puede cambiar su valor. Así, es valido hacer

Writeln(MiNombre);
if Longitud > LongitudMaxima then ...
OtraVariable := MiNombre;
LongCircunf := 2 * PI * r;

pero no podríamos hacer

PI := 3.14;
MiNombre := 'Nacho';
LongitudMaxima := LongitudMaxima + 10;

Las constantes son mucho más prácticas de lo que puede parecer a primera vista (especialmente para quien venga de lenguajes como Basic, en el que no existen -en el Basic "de siempre", puede que sí existan en los últimas versiones del lenguaje-). Me explico con un ejemplillo:

Supongamos que estamos haciendo nuestra agenda en Pascal (ya falta menos para que sea verdad), y estamos tan orgullosos de ella que queremos que en cada pantalla de cada parte del programa aparezca nuestro nombre, el del programa y la versión actual. Si lo escribimos "de nuevas" cada vez, además de perder tiempo tecleando más, corremos el riesgo de que un día queramos cambiar el nombre (ya no se llamará "Agenda" sino "SuperAgenda" ) pero lo hagamos en unas partes sí y en otras no, etc., y el resultado tan maravilloso quede estropeado por esos "detalles".

O si queremos cambiar la anchura de cada dato que guardamos de nuestros amigos, porque el espacio para el nombre nos había quedado demasiado escaso, tendríamos que recorrer todo el programa de arriba a abajo, con los mismos problemas, pero esta vez más graves aún, porque puede que intentemos grabar una ficha con una tamaño y leerla con otro distinto...

¿Solución? Pues definir todo ese tipo de datos como constantes al principio del programa, de modo que con un vistazo a esta zona podemos hacer cambios globales:

const
Nombre = 'Nacho';
Prog = 'SuperAgenda en Pascal';
Versión = 1.95;

LongNombre = 40;
LongTelef = 9;
LongDirec = 60;
...

Las declaraciones de las constantes se hacen antes del cuerpo del programa principal, y generalmente antes de las declaraciones de variables:

program MiniAgenda;
const
NumFichas = 50;
var
Datos: array[ 1..NumFichas ] of string;
begin
...

Tema 7.2: Constantes "con tipo".

const variable: tipo = valor;

Así, volviendo al ejemplo de la clave de acceso, podíamos tener una variables "intentos" que dijese el número de intentos. Hasta ahora habríamos hecho

var
intentos: integer;

begin
intentos := 3;
...

Ahora ya sabemos que sería mejor hacer, si sabemos que el valor no va a cambiar:

const
intentos = 3;

begin
...

Pero si se nos da el caso de que vemos por el nombre que es alguien de confianza, que puede haber olvidado su clave de acceso, quizá nos interese permitirle 5 o más intentos. ¿Qué hacemos? Ya no podemos usar "const" porque el valor puede variar, pero por otra parte, siempre comenzamos concediendo 3 intentos, hasta comprobar si es alguien de fiar. Conclusión: podemos hacer

const intentos: integer = 3;

begin
...

Insisto: una "constante con tipo" es exactamente igual que una variable, con las ventajas de que está más fácil de localizar si queremos cambiar su valor inicial y de que el compilador optimiza un poco el código, haciendo el programa unos bytes más pequeño.

Tema 7.3: Definición de tipos.

var PrimerNumero: integer;

indica que vamos a usar una variable que se va a llamar PrimerNumero y que almacenará valores de tipo entero. Si queremos definir una de las fichas de lo que será nuestra agenda, también haríamos:

var ficha: record
nombre: string;
direccion: string;
edad: integer;
observaciones: string
end;

Tampoco hay ningún problema con esto, ¿verdad? Y si podemos utilizar variables creando los tipos "en el momento", como en el caso anterior, ¿para qué necesitamos definir tipos? Vamos a verlo con un ejemplo. Supongamos que vamos a tener ahora dos variables: una "ficha1" que contendrá el dato de la ficha actual y otra "ficha2" en la que almacenaremos datos temporales. Veamos qué pasa...

 {--------------------------} 
 {  Ejemplo en Pascal:      } 
 {                          } 
 {    Intenta asignar dos   } 
 {    tipos definidos como  } 
 {    distintos. Da error   } 
 {    y no compila.         } 
 {    TIPOS1.PAS            } 
 {                          } 
 {  Este fuente procede de  } 
 {  CUPAS, curso de Pascal  } 
 {  por Nacho Cabanes       } 
 {                          } 
 {  Comprobado con:         } 
 {    - Turbo Pascal 7.0    } 
 {    - Turbo Pascal 5.0    } 
 {    - Surpas 1.00         } 
 {    - Tmt Pascal Lt 1.20  } 
 {--------------------------} 

 program PruebaTipos; 

 var 
   ficha1: record 
     nombre: string[20]; 
     direccion: string[50]; 
     edad: integer; 
     observaciones: string[70] 
   end; 
   ficha2: record 
     nombre: string[20]; 
     direccion: string[50]; 
     edad: integer; 
     observaciones: string[70] 
   end; 

 begin 
   ficha1.nombre := 'Pepe'; 
   ficha1.direccion := 'Su casa'; 

   ficha1.edad := 65; 
   ficha1.observaciones := 'El mayor de mis amigos...   '; 
   ficha2 := ficha1; 
   writeln( ficha2.nombre ); 
 end. 

¿Qué haría este programa? Es fácil de seguir: define dos variables que van a guardar la misma clase de datos. Da valores a cada uno de los datos que almacenará una de ellas. Después hacemos que la segunda valga lo mismo que la primera, e imprimimos el nombre de la segunda. Aparecerá escrito "Pepe" en la pantalla, ¿verdad?

¡Pues no! Aunque a nuestros ojos "ficha1" y "ficha2" sean iguales, para el compilador no es así, por lo que protesta y el programa ni siquiera llega a ejecutarse. Es decir: las hemos definido para que almacene la misma clase de valores, pero no son del mismo tipo.

Esto es fácil de solucionar:

var ficha1, ficha2: record
nombre: string;
direccion: string;
edad: integer;
observaciones: string
end;

begin
...

Si las definimos a la vez, SI QUE SON DEL MISMO TIPO. Pero surge un problema del que os iréis dando cuenta a partir del próximo día, que empezaremos a crear funciones y procedimientos. ¿Qué ocurre si queremos usar en alguna parte del programa otras variables que también sean de ese tipo? ¿Las definimos también a la vez? En muchas ocasiones no será posible.

Así que tiene que haber una forma de indicar que todo eso que sigue a la palabra "record" es un tipo al que nosotros queremos acceder con la misma comodidad que si fuese "integer" o "boolean", queremos definir un tipo, no simplemente declararlo, como estábamos haciendo.

Pues es sencillo:

type NombreDeTipo = DeclaracionDeTipo;

o en nuestro caso

 {--------------------------} 
 {  Ejemplo en Pascal:      } 
 {                          } 
 {    Asignación correcta   } 
 {    de tipos              } 
 {    TIPOS2.PAS            } 
 {                          } 
 {  Este fuente procede de  } 
 {  CUPAS, curso de Pascal  } 
 {  por Nacho Cabanes       } 
 {                          } 
 {  Comprobado con:         } 
 {    - Turbo Pascal 7.0    } 
 {    - Turbo Pascal 5.0    } 
 {    - Surpas 1.00         } 
 {    - Tmt Pascal Lt 1.20  } 
 {--------------------------} 

 program PruebaTipos2; 

 type TipoFicha = record 
     nombre: string[20]; 
     direccion: string[50]; 
     edad: integer; 
     observaciones: string[70] 
   end; 

 var ficha1, ficha2: TipoFicha; 

 begin 
   ficha1.nombre := 'Pepe'; 
   ficha1.direccion := 'Su casa'; 
   ficha1.edad := 65; 
   ficha1.observaciones := 'El mayor de mis amigos...   '; 
   ficha2 := ficha1; 
   writeln( ficha2.nombre ); 
 end. 

Ahora sí que podremos asignar valores entre variables que hayamos definido en distintas partes del programa, podremos usar esos tipos para crear ficheros (eso lo veremos en el tema 11), etc, etc, etc...