1

Arreglos y Registros

Sección 6.1

2

Acceso de arreglos

Un arreglo es una secuencia ordenada de objetos

idénticos.

El ordenamiento es determinado por un objeto de datos

escalar (usualmente entero o dato enumerado). Este

valor es llamado el subscripto o índice, y escrito

como A[I] para el arreglo A y subscrito I.

Arreglos multidimencionales tienen más de un subscrito.

Un arreglo de 2 dimensiones puede ser modelado como

cajas en una malla rectangular.

El L-value para un elemento del arreglo A[I,J]esta dado

por medio de una formula de acceso

3

4

Acceso al arreglo (continuación)

Rescribiendo la ecuación de acceso:

L-value(A[I,J]) = - d1*L1 - d2*L2 +I*d1 + J*d2

Haga I = 0; J= 0;

L-value(A[0,0]) = - d1*L1 - d2*L2 +0*d1 + 0*d2

L-value(A[0,0]) = - d1*L1 - d2*L2, que es una

constante.

Esta constante es denominada origen virtual (VO);

representa la dirección del elemento 0 del arreglo.

L-value(A[I,J]) = VO +I*d1 + J*d2

Para acceder un elemento del arreglo, use un dope vector:

5

Sumario del acceso a arreglos

Para crear arreglos:

1. Asigne un almacenamiento total empezando en :

(U2-L2+1)*(U1-L1+1)*tamañoelmt

2. d2 = tamaño

3. d1 = (U2-L2+1)*d2

4. VO = - L1*d1 - L2*d2

5. Para acceder A[I,J]: Lvalue(A[I,J]) = VO + I*d1 +

J*d2

Esto funciona para 1, 2 o más dimensiones.

Puede no requerir dope vector en tiempo de corrida si

todos los valores son conocidos en tiempo de

compilación. (por Ej.. En Pascal, d1, d2, y VO pueden

ser calculados por el compilador.)

6

7

Ejemplo de arreglos

Dado el siguiente arreglo: var A: array [7..12, 14..16] of

real;

Obtener el dope vector si el arreglo es almacenado empezando

en posición 500.

d2 = 4 (dato real)

d1 = (16-14+1) * 4 = 3 * 4 = 12

VO = 500 - 7 * 12 - 14 * 4 = 500 - 84 - 56 = 360

L-value(A[I,J]) = 360 + 12* I + 4* J

1. VO puede ser un valor positivo o negativo, y puede tener

Una dirección que es antes,

en, o después del almacenamiento

actual del arreglo:

2. En C, VO = debido a que el limite se inicia en 0.

Ejemplo: char A[25]

L-value(A[I]) = VO + (I-L1) * d1 = + I * 1 = + I

8

Slices

9

Arreglos tipo slices

Dado el arreglo: A[L1:U1, L2:U2]: Obtener d1, d2, y VO

para el vector:

Dope vector A[I,*] = B[L2:U2]

VO = L-value(A[I,L2]) - d2*L2

M1 = tamañoelmt = d2

Dope vector A[*,J] = B[L1:U1]

VO = L-value(A[L1,J]) - d1*L1

M1 = tamañofila = d1

Crear nuevo dope

vector que accese el

dato original

10

Más sobre slices

Slice diagonal:

VO = L-value(A[L1,L2])

- d1*L1 - d2*L2

M1 = d1 + d2

Otras posibilidades:

11

Arreglos asociativos

Acceso a la información por nombre sin tener un orden o

enumeración predefinido:

Ejemplo: Nombres y calificaciones para los estudiantes

de una clase:

NOMBRE[I] = nombre del I estudiante

CALIFICACION[I] = Calificación para el estudiante en

posición I

Arreglo asociativo: Usa Nombre como índice:

CLASE[nombre] será la calificación.

Problema: No se conoce la enumeración antes de obtener

los datos por lo que el método del dope vector no

funcionará.

Implementado en Perl y en SNOBOL4 (como una tabla)

12

Ejemplo en Perl

%ClassList = (“Michelle”, `A', “Doris”, `B', “Michael”,

`D'); # % operador hace un arreglo asociativo

$ClassList{„Michelle‟} # tiene el valor „A‟

@y = %ClassList # Convierte ClassList a una enumeración

# arreglo con índice 0..5

For ($i=0;$i<6;$i++){print “I=,$i,$y[$i]\n;”};

$I= 0 $y[$I] = Doris I=,0,Doris

$I= 1 $y[$I] = B I=, 1, B

$I= 2 $y[$I] = Michael I=, 2, Michael

$I= 3 $y[$I] = D I=,3, D

$I= 4 $y[$I] = Michelle I=, 4, Michelle

$I= 5 $y[$I] = A I=, 5, A

13

Estructuras en C

Representación: una

secuencia de objetos:

record { A: object;

B: object;

C: object }

14

Tipos de unión

typedef union { int X;

float Y;

char Z[4];} B;

B P;

Similar a registros, excepto que todos tienen

sobrelapamiento (el mismo) L-value.

Pero pueden ocurrir problemas. ¿Que sucede abajo?

P.X = 142;

printf(“%O\n”, P.Z[3])

Todos los 3 objetos de datos tienen el mismo L-value y

ocupan el mismo almacenamiento. No se realiza un

chequeo de tipo.

Diseño de lenguaje pobre

15

Registros variantes

type TipoPago=(Mensual, Hora);

var Empleado:record

ID: integer;

Dept: array[1..3] of char;

Age: integer;

case PayClass: TipoPago of

Mensual:(MonthlyRate:real;

StartDate:integer);

Houra:(HourRate:real;

Reg:integer;

Overtime:integer)

end