Variables, ámbito y comprobación de Tipos

Descripción de las variables

Comienza Ya. Es Gratis
ó regístrate con tu dirección de correo electrónico
Rocket clouds
Variables, ámbito y comprobación de Tipos por Mind Map: Variables, ámbito y comprobación de Tipos

1. 1. Variables

1.1. Las variables suelen tener:

1.1.1. 1.1 Nombre

1.1.1.1. Cadena de caracteres empleada para reconocer alguna entidad del programa

1.1.1.2. Son los identificadores más numerosos en los programas.

1.1.1.3. Subprogramas, parámetros formales y otras entidades de programa también poseen nombre o identificador.

1.1.1.4. Aspectos de diseño de nombres

1.1.1.4.1. Longitud Máxima

1.1.1.4.2. Carácetres conectores

1.1.1.4.3. Sensibilidad mayúsculas y minúsculas

1.1.1.4.4. Palabras Reservadas por el lenguaje

1.1.2. 1.2 Dirección

1.1.2.1. Dirección

1.1.2.1.1. Dirección de memoria a la que está asociada.

1.1.2.1.2. Un mismo nombre puede tener asociados diferentes direcciones en lugares diferentes del programa (funciones) o en momentos diferentes durante la ejecución del programa.

1.1.2.1.3. La dirección de una variable se denomina l -valor  la aparición de una variable en la parte izquierda de una asignación denota su dirección.

1.1.2.2. Alias

1.1.2.2.1. Cuando se usa más de un nombre de variable para referenciar la misma dirección.

1.1.2.2.2. Ejemplo: Si A y B son alias, entonces cualquier cambio en A también cambia B y viceversa.

1.1.2.2.3. Ayuda a ahorrar espacio pues la misma dirección se usa para almacenar tipos diferentes en momentos diferentes.

1.1.2.2.4. Ayuda a evitar las reglas de tipos de lenguajes.

1.1.2.2.5. En lenguajes que usan apuntadores, dos apuntadores son alias cuando apuntan a la misma localización de memoria.

1.1.3. 1.3 Tipo

1.1.3.1. Determina el rango de valores que puede tomar la variable y el conjunto de operaciones definidas permitidas.

1.1.4. 1.4 Valor

1.1.4.1. Contenido de la celda/s de memoria  a la que está asociada la variable.

1.1.4.2. El valor de la variable se denomina r-valor la aparición en la parte derecha de una asignación denota su valor.

1.1.4.3. Para acceder a un r-valor primero debe determinarse su l-valor.

2. 2. Ligadura (binding)

2.1. Asociación entre un atributo y una entidad.

2.2. El momento en que se produce se conoce como tiempo de ligadura, algunos ejemplos son:

2.2.1. Tiempo de compilación: ligadura de una variable a su tipo de dato en Pascal.

2.2.2. Tiempo de linkado: la ligadura de una llamada a un subprograma de biblioteca.

2.2.3. Tiempo de Carga: la ligadura de las variables a sus celdas de memoria.

2.2.4. Tiempo de ejecución: ligadura de las variables locales a sus celdas de memoria.

2.3. Ligadura Estática: si ocurre antes del tiempo de ejecución y no se altera durante la ejecución del programa.

2.4. Ligadura Dinámica: si ocurre o puede alterarse en tiempo de ejecución.

2.5. Tipos:

2.5.1. 2.1 Ligadura de Tipos

2.5.1.1. Antes de que una variable pueda ser referenciada en un programa debe ser ligada a un tipo de dato.

2.5.1.2. Aspectos importantes:

2.5.1.2.1. A. Ligadura Estática de tipos

2.5.1.2.2. B. Ligadura Dinámica de tipos

2.5.2. 2.2 Ligadura de espacio y tiempo de vida.

2.5.2.1. Proceso de asignación

2.5.2.1.1. Consiste en ligar celdas de memoria, tomadas de zonas de memoria disponible, a variables.

2.5.2.2. Proceso de desasignación

2.5.2.2.1. Consiste en  desligar las celdas de memoria de la variable y devolver las celdas a las zonas de memoria disponible.

2.5.2.3. Tiempo de vida

2.5.2.3.1. Es el tiempo durante el cual la variable está ligada a una localización específica de memoria.

2.5.2.3.2. Tiempo entre asignación y desasignación.

2.5.2.4. Clasificación de las variables (según su tiempo de vida y zona en memoria)

2.5.2.4.1. A. Variables estáticas

2.5.2.4.2. B. Variables dinámicas de pila

2.5.2.4.3. C. Variables dinámicas de montón (heap)

3. 3. Tipos

3.1. 3.1 Comprobación de Tipos

3.1.1. Generalización de los conceptos de operandos y operadores para incluir a subprogramas y sentencia de asignación.

3.1.1.1. Subprogramas:  operadores cuyos operandos son parámetros.

3.1.1.2. Asignación: operador binario cuyos operandos son la variable a la que se asigna el valor y la expresión a evaluar.

3.1.2. Comprobación de tipos

3.1.2.1. Actividad que asegura que los operandos de un operador son de tipos compatibles.

3.1.3. Tipos compatibles

3.1.3.1. Un tipo legal para el operador o un tipo que puede ser convertido implícitamente mediante código generado por el compilador.

3.1.4. Error de tipos

3.1.4.1. Aplicación de un operador a un operando de tipo inapropiado.

3.1.5. Si las ligaduras de tipos a variables son estáticas las comprobaciones de tipo pueden realizarse de forma estática.

3.1.6. Si hay ligadura dinámica de tipos a variables debe realizarse una comprobación dinámica de tipos.

3.1.7. Lenguajes que permiten el almacenamiento en la misma celda de valores de diferentes tipos deben realizar una comprobación dinámica.

3.2. 3.2 Disciplina de tipos

3.2.1. Un lenguaje tiene disciplina de tipos si los errores de tipos se detectan siempre.

3.2.2. Es necesario determinar los tipos de todos los operandos.

3.2.3. Ejemplos

3.2.3.1. Pascal

3.2.3.1.1. Cercano a tener disciplina de tipos pero no realiza comprobación de tipos en los registros variantes.

3.2.3.2. Ada

3.2.3.2.1. Resuelve el problema de los registros variantes realizando comprobación dinámica de tipos.

3.2.3.2.2. Tiene una función de biblioteca que permite extraer un valor de una variable de cualquier tipo y usar como diferente tipo.

3.2.3.3. C

3.2.3.3.1. No tiene disciplina de tipos

3.2.3.4. Java

3.2.3.4.1. Si tiene disciplina de tipos

3.2.3.5. ML y Haskell

3.2.3.5.1. Tienen disciplina de tipos

3.2.3.5.2. Los tipos de los parámetros de las funciones se conocen en tiempo de compilación.

3.3. 3.3 Compatibiidad de tipos

3.3.1. Métodos

3.3.1.1. Compatibilidad de tipos nominal

3.3.1.1.1. Dos variables tienen tipos compatibles si están ligadas al mismo nombre de tipo.

3.3.1.2. Compatibilidad de tipos estructural

3.3.1.2.1. Dos variables tienen tipos compatibles si sus tipos tienen la misma estructura.

3.3.1.3. Equivalencia de declaración

3.3.1.3.1. Dos variables tienen tipos compatibles si uno de los tipos está definido con el nombre del otro.

3.3.2. Tipo anónimo

3.3.2.1. Tipo asociado directamente con una variable mediante una declaración sin proporcionarle un nombre.

3.3.3. Compatibilidad de tipos nominal

3.3.3.1. Fácil de implementar pero muy restrictiva.

3.3.4. compatibilidad de tipos estructural

3.3.4.1. Debe compararse la estructura de ambos tipos, pero debe ser compatibles:

3.3.4.1.1. Registros

3.3.4.1.2. Arrays

3.3.4.1.3. Tipos ennumerados.

3.3.4.2. No se aceptan diferencias entre tipos con la misma estructura.

3.3.5. Subtipos y Tipos derivados

3.3.5.1. Subtipo

3.3.5.1.1. Versión de un tipo existente con el que es compatible. Evita uno de los problemas de la compatibilidad de tipos nominal.

3.3.5.2. Tipo derivado

3.3.5.2.1. Nuevo tipo basado en algún otro previamente definido con el que es incompatible, aunque sean estructuralmente idénticos. Heredan todas las propiedades de su tipo padre.

4. 4. Ámbito

4.1. Ámbito de una variable es el rango de sentencias en las que es visible la variable.

4.2. Una variable es visible en una sentencia si puede referenciarse en dicha sentencia.

4.3. Las reglas de ámbito de un lenguaje determinan cómo se asocian las referencias a variables declaradas fuera del subprograma que se está ejecutando con sus declaraciones

4.4. Una variable es local en una unidad de programa o bloque si está declarada en él.

4.5. Las variables no locales son aquellas visibles en una unidad o bloque pero no declaradas en él.

4.6. Tipos

4.6.1. 4.1 Ámbito Estático

4.6.1.1. Método de ligadura de nombres a variables no locales que ocurre en tiempo de compilación.

4.6.1.2. En la mayoría de lenguajes con ámbito estático pueden anidarse los subprogramas.

4.6.1.3. Cada subprograma crea su propio ámbito y el resultado es una jerarquía de ámbitos.

4.6.1.4. Atributos de una variable en un lenguaje con ámbito estático.

4.6.1.4.1. 1. Se busca su declaración local.

4.6.1.4.2. 2. Si no se encuentra, se continúa la búsqueda en el bloque que lo declara, su padre estático.

4.6.1.4.3. 3. Si no se encuentra, se continúa la búsqueda en la unidad que declara a esta última. Así hasta que se encuentra la declaración de la variable o se alcance la unidad de declaración mayor, el error.

4.6.1.5. Los padres estáticos de un subprograma se denominan antepasados estáticos.

4.6.1.6. En lenguajes con ámbito estático, una declaración de una variable oculta cualquier declaración de otra con el mismo nombre en un ámbito que englobe a ambas

4.6.1.7. Algunos lenguajes permiten definir nuevos ámbitos estáticos en mitad de código ejecutable.

4.6.1.8. Las secciones de código en la que se definen variables locales se denominan bloques.

4.6.1.8.1. Los bloques son el origen de la expresión lenguajes estructurados en bloques.

4.6.1.8.2. Ejemplos

4.6.1.8.3. Los ámbitos definidos por bloques se tratan igual que los creados por subprogramas.

4.6.1.8.4. Evaluación del ámbito estático

4.6.2. 4.2 Ámbito Dinámico

4.6.2.1. Basado en la secuencia de llamadas a subprogramas y no en la relación sintáctica entre ellos.

4.6.2.2. El ámbito se determina en tiempo de ejecucion

4.6.2.3. Atributos de una Variable

4.6.2.3.1. 1. Se busca su declaración local

4.6.2.3.2. 2. Si no se encuentra, se busca a su padre dinámico, el programa que realizó la llamada

4.6.2.3.3. 3. Si no se encuentra, se continúa la búsqueda en todos los antecesores dinámicos hasta encontrar la declaración. Si no se halla la declaración produce un error.

4.6.2.3.4. Evaluación del ámbito dinámico

4.6.3. 4.3 Entorno de Referencia

4.6.3.1. Colección de todos los identificadores visibles en dicha sentencia.

4.6.3.1.1. Lenguajes con Ámbito estático: entorno de referencia compuesto por las variables declaradas en su ámbito local y todas las variables visibles de sus antepasados estáticos.

4.6.3.1.2. Lenguajes con Ámbito dinámico: entorno de referencia compuesto por las variables declaradas localmente y todas las variables visibles del resto de subprogramas activos.

5. 5. Constantes

5.1. Constante

5.1.1. Objeto al que se le liga un valor sólo en el momento en el que se le liga el espacio

5.1.2. Su valor no puede cambiarse por asignación o por sentencia de entrada.

5.2. Ventajas

5.2.1. Aumenta fiabilidad y legitimidad del programa

5.2.2. El valor es mas fácil de modificar ya que aparece en una sola línea del programa.

5.3. Constantes manifiestas

5.3.1. Constantes con ligadura estática de valores

5.3.2. Ejemplo

5.3.2.1. Pascal: la declaración de una constante requiere un valor simple.

5.3.2.2. Modula-2: permite constantes  ya declaradas, literales y operadores.

5.4. Otros

5.4.1. Ada y java permiten ligadura dinámica de valores a constantes.

6. 6. Inicialización de variables

6.1. Inicialización

6.1.1. Ligadura de un valor a una variable en el momento de ligado del almacenamiento.

6.2. Variables estáticas

6.2.1. Inicialización sucede una vez antes de empezar la ejecución del programa.

6.3. Variables con ligadura dinámica de espacio

6.3.1. Con ligadura dinámica de espacio

6.3.2. Inicialización también es dinámica

6.4. Inicialización en algunos lenguajes

6.4.1. Pascal: no tiene sentencias de inicialización

6.4.2. C: puede indicarse un valor en la sentencia de declaración.

6.4.3. Ada: inicialización puede incluir nombre de otras constantes o variables visibles.

6.5. Variables no inicializadas

6.5.1. Crean variables no inicializadas

6.5.2. Se le liga memoria pero su contenido es arbitrario y no es interpretado como un valor del tipo objeto declarado.

6.5.3. Debe evitarse el uso de valores no inicializados porque producen resultados impredecibles.

6.5.4. Aproximaciones de los Lenguajes de Programación

6.5.4.1. Se considera responsabilidad del programador no emplear valores no inicializados.

6.5.4.2. Todas las declaraciones inicializan el espacio asignado a un valor apropiado.

6.5.4.3. No existen declaraciones sin inicialización, esto lo garantiza el programador.

6.5.4.4. Ejemplos

6.5.4.4.1. Pascal: ignora el problema

6.5.4.4.2. Ada: inicializa apuntadores null e ignora el problema para el resto de tipos.

6.5.4.4.3. C: inicializa las variables estáticas a una forma apropiada de cero. Ignora el problema para el resto de las variables.