TEMA 3: Datos

3.1

Variables

• Una variable es una séxtupla de atributos

• Nombre o identificador.

• Dirección.

• Valor.

• Tipo.

• Tiempo de vida.

• Ámbito.

3.1.1 Nombre o Identificador.

• Los identificadores más abundante son los que se refieren a nombres de variables. Pero también hay variables sin nombre.

• Reglas que rigen el diseño de los (nombres) indentificadores ( en general).

• ¿Cúal es la longitud máxima del identificador ?.

• ¿Pueden emplearse caracteres conectores?.

• ¿Se distiguen mayúsculas de minúsculas?.

• ¿Las palabras especiales son palabras claves o reservadas?.

• Id o nombre: cadena de caracteres de longitud variable.

Ej:

C -> limita la longitud a 31 caracteres.

Ada -> no limitan la longitud.

C++-> No dice nada en la especificación.

• Caracteres conectores: La mayoría de los lenguajes permiten que se utilice el caracter...

• Distinción Mayusculas de Minusculas: C,C++,Modula-2 distinguen el uso de las mayúsculas de las minúsculas ( son case-sensitive).

Ej:

Suma, suma, SUMA -> 3 identificadores diferentes.Violan el principio de legibilidad.

En Modula-2: WriteInt ( nombre de módulo predefinido). Hay que escribirlo así siempre.

• Palabras Clave o reservadas: if, while son palabras especilaes.

• Si las palabras son claves; se trata de palabras que sólo son especiales en ciertos contextos. Ej:

Fortran : REAL ALTURA ( ALTURA es del tipo REAL)

REAL = 8.5 ( aquí REAL es un identificador )

REAL INTEGER

INTEGER REAL

• Se habla de palabras reservadas cuando son palabras especiales que no pueden emplearse por el usuario como identificadores. En estos lenguajes que usan palabras reservadas hay:

• Identificadores predefinidos.Tienen un significado predefinido pero pueden cambiar de usuario.

• Ej: llamadas afunciones de librería.

C-> printf, scanf

Pascal-> write, read

Ada-> get, put ( aquí en Ada el usuario puede redefinir el sentido de estos identificadores).

3.1.2 Dirección:

• Es la dirección de memoria a la que está asociada la variable. Yo puedo tener un identificador “i” en las funciones f1 y f2 y en cada una “i” tiene direcciones de memoria diferentes.

• Si f es una función recursiva: En cada activación del procedimiento i tiene una dirección de memoria diferente en la pila A la dirección de memoria también se le conoce como L-valor:

v:= E ( para realizar la asignación necesito conocer la dirección de r ).

L - valor -> ( el valor de la parte izquierda de una operación de asignación ).

• Alias: Tendremos un alias cuando hay más de un nombre de variable para acceder a una misma localización de memoria.

• Creación:

• Hay lenguajes donde se crean de forma explícita. Ej:

FORTRAN -> EQUIVALENZE

COBOL -> REDEFINES

• En Pascal y en Ada mediante registros variantes. En C y C++ mediante unions.

• Se puede acceder en momentos diferentes a nombres de variables diferentes.

Ej: Pascal;

Type coordenadas = record case clase:(cartesiana, polar) of

cartesiana: (x,y: real);

polar:(r,fi: real);

end;

• Otra forma de crear alias es empleando paso de parámteros por referencia en los subprogramas. ( si pasas un parámetro por referencia ya tienes 2 referencias a esa variable ).

• En lenguajes con apuntadores cuando 2 o más apuntadores referencian la misma zona de memoria tambien se están creando alias.

NOTA: Para nosotros todos los tipos no estructurados ocupan una celda .

3.1.3 Tipo

• El tipo de dato de una variable va a determinar:

• El rango de valores.

• El conjunto de operaciones definido para ese tipo de dato.

Ej:

rango de valores: -32768..32767.

Integer

operaciones : +, -, *, /.

3.1.4 Valor

• El valor de una variable es el contenido de la celda de memoria asociada a esa variable. Al contenido de una celda de memoria se le denomina R-valor: v:= i + 1;

Para obtener el r-valor de una variable necesito saber primero el L-valor de esa variable.

3.1	Vinculación (Binding)

• Cuando se produce una asociación entre una atributo o entre una operación y un símbolo. Al momento e n el que se produce esa vionculación es a lo que se denomina tiempo de vinculación. En general vamos a hablar siempre de:

• vinculación estática si ésta se produce antes del tiempo de ejecución y permanece inalterable durante toda la ejeccución del programa.

• Vinculación dinámica: durante el tiempo de ejecuciòn o cambia en el transcurso del programa.

3.2.1 Vinculación de Tipos.

• En cualquier lenguaje de programación antes de la ejecución de una variable hay que saber la vinculación de tipos.

• VINCULACIÓN ESTÁTICA DE TIPOS.

Puede realizarse de manera explíctita o de una manera implíctita.

• De forma explícita: El lenguaje tiene una lista de variables a las que se asigna un tipo: int i,j;

• De forma implícita.- No se utilizan estas sentencias, sino que el tipo se asocia a través de determinadas convenciones. La asociación de tipos se produce la 1º vez que aparece la variable. El compilador ya entiende el tipo a través de las convenciones.

Ej:

BASIC, FORTRAN -> I,...,N

I = H * L ( el compilador deduce el tipo de las variables H y L.

• Hay otra forma del tipo de declaración implícita ( ML, HASKELL) donde se emplea el algoritmo de inferencia de tipos. Si no se indica el tipo de las variables, entonces los lenguajes o infieren un tipo, o presentan un mensaje de error .

• VINCULACIÓN DINÁMICA DE TIPOS

• Hay que tener en antes de empezar este punto que las vinculaciones estática e implicita es total

• En este caso el tipo no se especifica mediante ningún tipo de declaración, sino cuando se le asigna por primera vez mediante una sentencia de asignación.

Ej:

APL

LISTA <- 8.1, 3.0, 0.5, 6.25. ( lista de cuatro elementos de números reales ).

LISTA <- 3. ( un número entero ).

• Ventaja: Este tipo de programación da gran flexibilidad al programador.

• Desventajas:

• No se detectan muchos errores de tipos.

Ej:

i, x -> enteros.

y -> real.

I:= y / i:= x No da error en vinculación dinámica de tipos , convierte a i en real.

Existen también coacciones de tipo:

i:= y.

• El coste de implementación en tiempo de ejecución (elevado coste de asignación y desasignación de espacio).

3.2.2 Vinculación de espacio y tiempo de vida.

• La vinculación de espacio significa que desde algunas zonas de memoria disponibles se vinculan celdas de memoria a un a variable: asignación. El proceso de desasginación: se devuelve a una zona de memoria libre el espacio que hasta entonces estaba asignado a una variable.

• Tiempo de vida de una variable: Es el tiempo durente el cual la variable está vinculada a un lugar específico de la memoria ( tiempo que transcurre entre la asignación y la desasignación).

• Vamos a clasificar la vinculación de espacio atendiendo al tiempo de vida de la variable.

• Variables estáticas. La vinculación de espacio se produce antes de que se comience a ejecutar el programa. Permanecen vinculadas a las mismas celdas hasta que acaba la ejecución del programa. Las variables globales son variables estáticas. Muchas veces en los subprogramas nos interesa que la variable recuerde el valor entre llamadas diferentes: "sensibles a la historia". En C las variables locales se puenden transformar en esáticas a través de static.

Sus ventajas son:

• La eficiencia

• Todas estas variables pueden tener un direcciónamiento directo.

• No hay sobrecarga de asignación o desasignación en tiempo de ejecución.

Su desventaja:

• Falta de flexibilidad, por ejemplo no se permite la recursividad.

• Variables dinámicas en pila. En este tipo de veriables la vinculación se produce en el momento de la elaboración de la sentencia de declaración. Entendemos elaboración de la sentencia de declaración cuando en el momento de la ejecucuión de sentencia se vincula espacio a las variables que se indican. Esta elaboración está sucediendo en tiempo de ejecuacuón.

Ej: Pascal

VAR: sección de declaración -> se elabora antes de la ejecución del código.

BEGIN

sección del código -> variables locales.

END

Por tanto la asignación de espacio ocurre en tienpo de elaboración y la desasignación ocurre al finalizar el subprograma (procedimiento o función).

• Se denominan de pila porque el espacio se asigna en la pila de ejecución. Cada vez que se ejecuta un procedimiento aparece en la pila un bloque de asignación. Variables locales- > Se declaran en los subprogramas.

Ventajas:

• Si todas la s variables son estáticas, debemos guartadar en la zona de memoria espacio para todas ellas.

• Si el lenguaje proporciona variables dinámicas de pila, estoy utilizando el mínimo espacio para todas las variables, a medida que voy utilizando procediminentos voy haciendo reserva de pila ( zona común para todas las variables de pila).

• Permiten recursión.

Desventajas:

• Sobrecarga relativa en tinepo de ejecucuón.

• No son sensibles a la historia, no conocemos el valor que tenían al hacer una siguiente llamada.

• Variables dinámicas de Heap.

• Heap: colección de celdas de memoria que se caracteria por tener una estrucutura muy desorganizada debido a que tiene un uso de sus celdas de manera impredecible.

• Variables dinámicas del Heap:

• Explícitas: Son variable sin nombre. Su asignación o desasiganción se realiza en tiempo de ejecución, decidiendolo el programador ( coloca una instrucción allí; al efecto ).Se referencian mediante apuntadores

Ej:

Creacción / destrucción mediante operador:

C ++, new / delete.

Creacción / destrucción mediante función de librería:

C; Pascal: malloc() / free(); new() / dispose ()

Ej:

C++

cnt *apentero;

.........................

apentero = new int; // Reservamos una celda del Heap

..........................

delete apentero; // Se desvincula ( la celda pasa a estar libre ).

• Se usan para crear estructuras del tipo lista, árboles...

Desvetajas: Sobrecarga en tienpo de ejcución (El coste en tiempo de ejecución son la asigneción + la desasigneción + la referencia) y la dificultad de uso.

• Implicitas:

• La vinculación del espacio se produce casa vez que se le asignan valores a las variables ( no se produce por la instrucción que coloca el programador ).

Ej:

APL

Lista <- 4.0, 3.5, 7.12

Lista <- 8.

Ventaja: Flexibilidad en la programación.

Desventajas:

- Sobrecarga que se produce en tiempo de ejecución.

- Se dejan de detectar algunos errores de tipo.

3.3

Tipos

3.3.1 Comprobación de Tipos.

• Los subprogramas son operadores; por tanto los parámetros de los subprogramas son los operandos

• Asignación -> operador binario.

Bajo estas suposiciones definimos:

• Comprobación de tipos: es la actividad que nos asegura que los operandos de un operador son de tipos compatibles.

• Tipos compatibles: si se trata de un tipo legal paraa ese operador o bien atendiendo a algunas reglas del lenguaje puede ser convertido (de manera ímplicita atendiendo siempre a reglas del lenguaje y empleando un código que genera el compilador a tal efecto ), en un tipo legal. Esta conversión se llama coacción. ( coerción).

• ¿ Cuándo se produce un error de tipos ?. Cuando se emplea un tipo inadecuado del operador que se está utilizando.

• Vinculación estática de tipos a variables .- comprobación de tipos puede ser estática. ( podemos comprobarlo también en tiempo de compilacción ).

• Vinculación dinámica .- La comprobación debe ser dinámica.

• Pascal , Ada, C permiten estructuras de tipo registros variantes o uniones-> la comprobación dinámica de tipos. Pascal y C no realizan una comprobación de tipos para sus registros variantes con lo cual nos puede dar errores de ejecución o podemos recuperar algo que no es lo que queríamos recuperar ( Ada sí ).

3.3.2 Asignación fuerte de tipos ( Strongly typed )

• Un lenguaje tiene asignación fuerte de tipos si cada identificador del lenguaje tiene asociado un sólo tipo, y este tipo se conoce en tiempo de compilación. ( aquellos lenguajes que realizan una vinculación estática de tipos ). Esta definición no engloba a registros variantes o uniones.

• Un lenguaje tiene asignación fuerte de tipos si los errores de tipos se detectan siempre. Esta definición no dice si la vinculación va en tiempo de compilación ó ejecución, es una definición más amplia.

• Pascal no es un lenuaje de asignación fuerte de tipos porque posee registros variantes y no realiza una comprobación dinámica de tipos para estos registros variantes y por tanto no detecta errores para esta estructura en cuanto a tipos.

• Ada. Resuelve el problema de los registros variantes realizando una comprobación dinámica de tipos, pero, posee una función de librería que nos permite extraer el contenido de cualquier zona de memoria como un string de bits que puedo asignar a cualquier variable- > estamos escapando de la asignación fuerte de tipos. Ada no tiene asignación fuerte de tipos.

• C. No tiene asignación fuerte de tipos ya que tiene unions. C permite funciones con parámetros sobre los que no se realiza comprobación de tipos.

Ej:

printf("%s", 25); // No da error en tiempo de compilación pero sí en tienpo de ejecución.

( No se detectan todos los errores de tipo ).

• Lenguajes con asignación fuerte de tipos: ML, Haskell realizan un comprobación fuerte de tipos.

3.3.3 Compatibilidad de Tipos (Equivalencia de tipos ).

• Si dos variables son compatibles sus valores se pueden asignar ( el valor de una se puede asignar a la otra y viceversa ).

• Para saber si dos tipos son compatibles existen 2 métodos:

• Compatibilidad de tipos normal: Dos variables tiene una compatibilidad de tipos normal si se declaran en el mismo lugar o en declaraciones que usan el mismo nombre de tipo.

• Compatibiliodad de Tipos Estructural: Si poseen la misma estructura.

• C.T. NOMINAL.

• Fácil de implementar ( lo único que hay que hacer es comparar el nombre de tipo de ambas variables).

• Puede llevar una interpretación estricta:

Ej: Pascal

Type

tipo_indice = 1..100;

Var

contador: integer;

indice: tipo_indice;

Son incompatibles l ...

• Otro problema es el paso de estructuras como parámetros.

Ej: Pascal (pasar un array).

Procedure x (Var a:array[1..10] of integer). { Esto da un error de tipos}

• COMPATIBILIDAD DE TIPOS ESTRUCTURAL

• Se comprueba la estructura

• ¿Dos registros con igual estructura pero con nombres de campos distintos son incompatibles ?.

• ¿Dos arrays son cammpos distintos pero del mismo tipo son incompatibles ?.

[1..10] of integer

[0..9] of integer

• ¿Enumerados con igual número de elementos pero distintos nombres?

• Estos tres últimos puntos los tiene que decidir el diseñador del lenguaje, mientras que el lenguaje tendrá que dar la respuesta.

Ej:

Type

Celsius = real;

Farenheit = real;

Var

C: Celsius;

F: Farenheit;

c:= t;

f:= c;

La compatibilidad nominal no permitiría esto.

Vamos a ver que ocure en Pascal, Ada y C:

• Pascal.

Mezcla de la C.T .Nominal y esstructural:

Type

tipo1 = array[ 1..10] of integer;

tipo2 = array[ 1..10] of integer;

tipo3 = tipo2;

i de tipo 1

incompatibles

j de tipo2

j de tipo2

compatibles. Aplica la equivalencia de declaración.

k de tipo3

• Ada.

Emplea C.T. Nominal en general.

Ofrece 2 constructores de tipos:

- Subtipo ( C.T.Estructurado).

- Tipo derivado.

• Tipo derivado.- Se define a partir de otro tipo. El que se está definiendo resuelta incompatibles con el predecesor ( pero hereda todas la propiedades de éste ). Por ejemplo: Type celsius is new float; Type farenheit is new float;

Celsius es incompatinble con float.

Farenheit es incompatible con float.

Farenheit es incompatible con celsius.

( Las constantes se tratan aparte ).

Constantes 6.0, 8.7 -> se entienden que son de un ...

• Subtipos

Subtipo natural is integer range 0.. integer'last.

Subtipo calificación is integer range -3...+3.

Natural no es incompatiblecon integer.

Calificación no es incompatible con integer.

Calificación no es incompatible con natural.

Todos los tipos tiene compatibilidad estructural: c:= n Aquí hay una C.T.Estructural. En compilación lo pasa, luego en tiempo de ejecución deberá comprobar los rangos.

Ej:

function "**" ( i: integer; n: natural) return integer;

j**k ( k puede ser: natural, calificacción o entero.

• C: Se emplea C.T.Estructural excepto para registros y uniones ( que se emplea equivalencia de declaración ): Typedef es un nuevo nombre paraun tipo ya existente. Hay lenguajes que permiten definir variables de tipos anónimos.

Var

a: array[1 ..10] of integer;

b: array[1..10] of integer;

array es un tipo anónimo, a y b son tipos anonimos incompatibles

Hay lenguajes,

a,b: array[1..10] of integer;

Incompatible en Ada. Para que sean compatibles habría que definir un tipo de manera expícita, pero es compatible con Pascal.

3.4

Ámbito

• El ámbito de una variable es el rango de sentencias en que dicha variable es visible. Una variable es visible en una sentencia si puede regerenciarse en la misma

• La reglas de ámbito en un lenguaje son muy importanrtes. La forma de esasa reglas va a determinar que un identificador en un programa se asocie a una variable o se asocie a otra.

- Variables locales.

- Variables no locales. La variable no se declara en ese subprograma.

3.4.1 Ámbito Estático

• Método de vinculación de nombre de identificadores a variables no locales que ocurre en tiempo de compilación.

• El ámbito son las variables declaradas como locales al procedimiento más la colección de todas las variables del ámbito de subprograma antecesor que son visibles para éste. El ámbito, en este caso, es necesitado durante la compilación.

• En Pascal, el ámbito es creado sólo por las declaraciones en los procedimientos. El ámbito incluye las variables locales más todas las variables declaradas en los procedimientos en los cuales el conjunto de sentencia es necesitado y más las variables declaradas en el programa principal.

• ¿Cómo se determinan los atributos de una variable en un lenguaje con ámbito estática?(Transparencia)

• Buscar la declaración local en el subprograma 1 y si no se encuentra.

• Se continúa la búsqueda en el subprograma que contiene o declara al subprograma, este programa es el padre estático de subprograma1 sino continuaría la búsqueda en todos los antepasados estáticos de sub1

• Termina la búsqueda cuando se encuentra la declaración de x o se ha llegado a inspeccionar la unidad mayor.

• Los estáticos pueden ocultar variables antepasadas.

• Ada - Aunque una variable esté oculta permite hacer referencia a esta variable: Nombre_unidad_programa.nombre_variable

• Algunos lenguajes herederos permiten definir nuevos ámbitos estáticos en mitad del código ejecutable (En éstos ámbitos puede haber nuevas variables locales).

• Bloque: Fracción de código en la que puede definirse variables locales. Da orígen a los lenguajes estructurados en bloques.

• Pascal -> Lenguaje estructurado en bloques, todos los bloques son procedurales (procedimientos o funciones ).

• C -> Cualquier grupo de sentencias entre llaves, las primeras sentencias de ese bloque pueden ser declaraciones (estas son variables dinámicas de pila -> Se asigna espacio a

las variables al entrar en cada bloque

• Ada -> En cualquier punto del código puedo escribir

Declare temp: integer ; <- Temp es vble. Din. Pila

Begin

temp:=x

x:=y

y:=temp

end

• El ámbito estático proporciona un método de acceso a variables no locales que es el apropiado en la mayoría de las ocasiones.

• Desventajas :

• Acceso a demasiados datos (todas las vbles. Declaradas en el principal son visibles en todos los procedimientos hijos sintácticos de él )

• Los cambios pueden ser complicados

Principal principal

A

C A B

D C D E

B

E

Ejemplos de soluciones para cambios:

Mover E dentro de D -> deja de tener acceso al ámbito de B con lo que podría no funcionar.

Mover las variables de D que necesite E al principal -> estas variables también son accesibles a A y a B (demasiados datos ) y puede que las vbles que yo necesite es x declarado en D y la muevo al principal y existe otra x en A habría que renombrar las variables ( si llamamos desde D llamo a la de A y no al principal)

Hacer cambios para que un procedimiento pueda llamar a otro enun lenguaje de ámbito

estático puede se complicado.

La tendencia de los programadores es usar más variables globales de las que necesita.

3.4.2 Ámbito Dinámico

• Son las variables declaradas localmente más las variables de todos los subprogramas que están activos de forma concurrente.

• Lenguajes como APL.

• Se basa en la secuencia de llamadas a subprogramas

• Solamente puede determinarse el ámbito dinámico en tiempo de ejecución.

Significado de x:

• Comienza la búsqueda en las declaraciones locales.

• Se busca en las declaraciones de su padre dinámico (procedimiento que le llamó),

• sino la búsqueda prosigue con los antepasados dinámicos.

Ej. (transparencia)

. mayor->sub2->sub1

x es real, es la vble. Declarada en sub2

(tenemos que saber cual es el padre dinámico y se conoce en tiempo de ejecución)

. mayor->sub1

x es integer, es la variable declarada en mayor

• Desventajas :

• Las mismas referencias pueden tener significados diferentes en ejecuciones diferentes. (Todas las v. Locales de todos los procedimientos son visibles en los otros procedimientos a los que llama => acceso a demasiados datos)

• Accesibilidad desde todos los subprogramas a los que se llama => menor fiabilidad

• Imposibilidad de hacer una composición de tipos estática para las v. No locales.

• Los programas son más difíciles de leer y seguir

• Ventajas :

• El subprograma llamado hereda el contexto de sus llamadores.

(Def. Ambito dinámico: Variables declaradas localmente más las variables de todos los subprogramas que están activos de forma concurrente.)

3.4.3 Entorno de Referencia

• Variables que se pueden referenciar desde un lugar determinado.

• Conjunto de todos los identificadores visibles en dicha sentencia.

• Lenguaje de ámbito estático: Vbles. Locales + vbles. De los antepasados estáticos exceptuando las vbles. Que se ocultan

• Lenguaje de ámbito dinámico: vbles. Locales + V. Declaradas en los antepasados dinámicos.

Variables que se pueden referenciar desde un lugar determinado.

3.5	Constantes

(Constantes con nombre)

Es un objeto al que se vincula a un valor sólo en el momento en el que se vincula el espacio.

(El valor de una constante no se puede modificar por asignación o sentencia de entrada)

• Una constante es una variable que está vinculada únicamente a un valor.

• Su valor no puede ser cambiado mediante una sentencia de asignación o cualquier otre sentenmcia.

• Las constantes son útiles para permitir una mejor legibilidad y fiabilidad.

• Otras ventajas de usar constantes es en programas que procesan un número fijado de valores de dato.

3.6	Inicialización de Variables

• La discusión de vincular valores a constantes conduce naturalmente al tópico de inicialización de variables, porque la vinculación de un valor a una constante es el mismo proceso, excepto porque éste es permanente.

• Es conveniente que las variables tengan un valor antes de utilizarse.

• Inicialización : Vinculación de un valor a una variable en el momento en el que se vincula el

espacio.

• C-> Puede especificarse la inicialización en el momento de la declaración

Int i=10

• Las variables estáticas se inicializan una sola vez (cuando se asigna el espacio) las variables dinámicas de pila se inicializan también cuando se ejecuta el bloque que contiene esa declaración.

Variables no Inicializadas:

C -> int i;

• Aproximaciones a las soluciones:

• Se ignora el problema (bajo responsabilidad del programador)

• No permite el uso de valores no incializados (averiguándolo en tiempo de compilación analizando la parte derecha de todas las variables y comprobar que tienen valor)=> mayor costo

• Todas las declaraciones inicializan el espacio asignado a un valor apropiado por defecto para cada tipo básico.

• Utilizan un valor especial para cada tipo: omega (Cuando una variables tiene el valor omega es que no está inicializada) :I+3 > omega (i omega)

• Modula2 y PASCAL -> Ignoran el roblema

• Ada -> Los apuntadores se inicializan a NULL y se ignora el problema para el resto de tipos

• C-> Las vbles. Estáticas se inicializan a una forma apropiada de cero y se ignora el problema para el resto de variables.

Tema 3: Datos LPR

1

13