VARIABLES (1ª PARTE) CAPITULO-2
Las variables son el "sitio" donde podemos
guardar los datos que el programa necesite. En Pascal las variables hay que
definirlas antes de usarlas y hay que aplicares un tipo.
Esto significa que al principio del programa tenemos que decir
qué variables vamos a usar y qué tipo de datos van a contener. Para declarar
una variable lo hacemos después de la palabra reservada "Var" y de la
siguiente forma:
Var
Variable1: Tipo;
Variable2: Tipo;
Variable3,
Variable4: Tipo;
Si dos o más variables van a ser del mismo tipo podemos
ponerlas en lineas separadas o en una misma línea separadas por comas. Por hoy
veremos sólo los tipos simples
BYTE (8 bits, 0..255)
En tipo byte define una variable que ocupará 8 bits de memoria
(un byte) y esta variable podrá contener valores desde el 0 hasta el 255, ambos
incluidos.
SHORTINT (8 bits, -128..127)
Define una variable que ocupa 8 bits y puede tomar valores
de -128 a 127. Con estas variables hay que tener cuidado porque 127+1=-128.
CHAR (8 bits, carácter)
Define una variable de 8 bits pero que no contiene
valores sino cualquier carácter ASCII.
BOOLEAN (8 bits, verdadero-falso)
Define una variable de 8 bits que sólo puede contener dos
valores: TRUE (verdadero) o FALSE (falso).
INTEGER (16 bits, -32768..32767)
Define una variable de 16 bits (2 bytes) que puede contener
valores desde -32768 hasta 32767. Sucede lo mismo que con el tipo Shortint:
32767+1=-32768.
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 -2147483648 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 estándar 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 veáis 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 que 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".
DESCARGAR CAPITULO 1 VERSIÓN PDF
CAPITULO 3
0 comentarios: