1. TDA ARRAYU
ESTRUCTURAS DE DATOS

2. OBJETIVOS
 Definir un nuevo TDA utilizando las técnicas ya revisadas
 Implementar TDAs usando un lenguaje de programación y
técnicas de modularización
 Reconocer la utilidad de un tipo de dato Generico
 Utilizar TDAs ya creados para resolver problemas

3. INTRODUCCION
 Los tipos de datos básicos
 Enteros, reales, caracteres, lógicos
 Son también de alguna forma TDAs
 Cuando se desea sumar dos enteros
 No es necesario conocer la representación binaria de cada valor
entero
 Solo debe conocerse el comportamiento que hace la suma: (+)
 Básicamente todos los tipos de datos se pueden considerar
TDAs

4. ¿Qué ES UN ARREGLO?
 El arreglo es un tipo de dato compuesto
 Permite agrupar elementos del mismo tipo
 Permite acceder a CADA elementos utilizando su
posición, recordemos que se puede
 Consultar el valor de un elemento
 Modificar el valor de un elemento
 Lenguaje C si nos permite trabajar con arreglos

5. ARREGLOS EN C
 C ya provee de una forma de trabajo con arreglos
 En forma estática o dinámica, como se desee
 Podemos declararlos. Ejemplo:
 int A[20] o int *A;
 Y modificar y consultar los elementos. Ejemplo:
 A[5] = 4 o printf(“%d”, A[5])
 Si el TDA Arreglo en C ya provee el
comportamiento necesario
 ¿Por que crear otro tipo de dato que lo sustituya?

6. LOS PROBLEMAS
 Características negativas de un arreglo en C
 Si es un arreglo estático,
 El tamaño real debe ser determinado desde el inicio, lo cual es muy molestoso
 Si es un arreglo dinámico
 El uso de malloc para crearlo abarca una cierta “complejidad” que podriamos
ocultar
 Puedo intentar asignar valores a elementos fuera del rango del arreglo
 Los índices siempre comienzan desde 0 y eso no se puede cambiar
 El tamaño del arreglo no es parte del arreglo
 etc.…
 Existen demasiadas características de los arreglos
 Que añaden complejidad al manejo de arreglos
 Recordemos la abstracción: quitar complejidad, dejar solo lo necesario

7. UN NUEVO TDA: ARRAYU
 Una abstracción “arreglaría” estos detalles
 Crearíamos un nuevo tipo de dato que
 Solo muestre lo que se necesita y esconda la complejidad
 Podríamos crear el nuevo TDA para arreglos
unitarios
 ArrayU

8. DISEÑO DEL TDA: NIVEL
LOGICO
 El diseño de un TDA implica
 Determinar el comportamiento del mismo: operaciones
 Determinar la definición interna del mismo:
características
 Este diseño también se puede llamar
 Nivel lógico del TDA
 Pensemos en el nivel lógico para
 Nuestro nuevo arreglo: ArrayU

9. ArrayU: COMPORTAMIENTO
 Existen dos niveles de comportamiento:
 Básico: sin el cual no se puede trabajar con el TDA
 Complementario: operaciones que facilitan el manejo del TDA
 Comportamiento básico: A un ArrayU se debe poder
 Crearlo, de cualquier tamaño
 Destruirlo
 Asignar un valor a uno de sus elementos
 Consultar el valor de uno de sus elementos
 Consultar el tamaño máximo del arreglo
 Comportamiento complementario
 Ordenarlo
 Buscar un elemento dado su valor, etc.

10. ArrayU: ESTADO
 Primero es útil pensar la definición de nuestro TDA
 Un arreglo es
 Una colección de elementos finita y de tamaño fijo.
 A cada elemento se lo puede acceder por un índice
 El índice del primer elemento puede comenzar desde un numero dado
 El índice del ultimo elemento seria igual a: indice_primero + tamaño -1
<arreglo> ::= {<elemento><inicial>, ... , <elemento><iterador>, <elemento><final>}
<iterador> ::= (<inicial>|<inicial>+1|<inicial>+2|...|<final>)
<inicial> ::= <entero_positivo>
<final> ::= <inicial>+<nreal>-1
<nreal> ::= <digito>{<digito>}
<elemento> ::= <dato>{<dato>}

11. TDAs: NIVEL DE
IMPLEMENTACION
 Una vez completo el nivel lógico,
 Podemos pasar al nivel de implementación
 Usando un lenguaje de programación determinado
 Hay algunas consideraciones que tomar
 Estándar para nombrar TDAs y operaciones
 Es preferible crear un estándar
 Útil para todos los TDAs que se vayan a crear
 Ejemplo:
 <nombre_TDA>_<nombre_funcion> o
 <nombre_funcion><nombre_TDA>
 Uso de modularidad a nivel de archivo

12. MODULARIZACION DE
ARCHIVOS
 En la programación estructurada, los TDAs se implementan en
módulos
 Un modulo normalmente esta compuesto por:
 Interfaz o especificación, en lenguaje C, se refiere a los archivos .h:
 Contienen la declaración del nuevo tipo y
 Los prototipos de las operaciones que estarán disponibles
 Implementación, en lenguaje C, se refiere a los archivos .c
 Contendrá el código fuente de cada operación
 Cada implementación o “forma de llevarse a cabo” de las operaciones, estarán
ocultas para el mundo exterior
 En resumen, un TDA bien modularizado a nivel de archivo, ocupará
 Dos archivos, un .h y un .c, con el nombre del TDA

13. ARRAYU: NIVEL DE
IMPLEMENTACION
 Crear
 Dado un tamaño, ArrayU almacenara una arreglo de dicho tamaño
ArrayU *ArrayU_Crear (int tamanio, int inicial);
 Eliminar
 Dado un arreglo, se eliminara de memoria
void ArrayU_Eliminar(ArrayU **A);
 Consultar
int ArrayU_ GetElemento(ArrayU *A, int indice);
Int ArrayU_GetTam(ArrayU *A);
int ArrayU_GetInicial(ArrayU *A);
Int ArrayU_GetFinal(ArrayU *A);
 Modificar
void ArrayU_SetElemento(ArrayU *A, int indice, int valor);

14. ARRAYU: NIVEL DE
IMPLEMENTACION
 Consideraciones
 Un arreglo es el conjunto de elementos
 Con un tamaño dado y un numero de índice inicial
 Declaración:
typedef struct{
OJO: ArrayU int *Arreglo;
solo servirá
para arreglos int nreal;
de enteros int inicial;
}ArrayU;

15. ARRAYU: NIVEL DE
APLICACION
 Ahora que hemos construido nuestro nuevo TDA
 Podemos usarlo en un programa
 Veamos un ejemplo de esto en el siguiente
ejercicio
 Pedir n elementos por teclado, almacenarlos en un
arreglo y luego mostrar la mitad de cada valor ingresado
 No usaremos mas los arreglos que conocíamos
 Usemos nuestra propia abstracción

16. LEER, CAMBIAR E IMPRIMIR
main(){
ArrayU *Datos;
int n, valor;
printf(¿Cuántos datos maximo desea ingresar?);
n = GetInteger();
Datos = ArrayU_Crear(n,1);
for(i = ArrayU_GetInicio(*Datos); i <= ArrayU_GetFinal(*Datos);i++){
//Inicio i en el for desde 1, no desde 0
printf(“Ingrese el dato No.”, i);
valor = GetInteger();
ArrayU_SetElemento(Datos,i, valor); //Pido el elemento i
}
for(i = ArrayU_GetInicio(*Datos); i <= ArrayU_GetFinal(*Datos);i++){
valor = ArrayU_GetElemento(*Datos,i)/2;
ArrayU_SetElemento(Datos, i, valor);
printf(“Mitad del elemento %d: “, valor);
}
ArrayU_Eliminar(&Datos);
}

17. SOLO PARA ENTEROS
 ArrayU ha sido un éxito, pero
 Lo implementamos solo para enteros
 Dos posibles soluciones
 Crear un TDA para cada tipo de dato
 ArrayUI, solo para enteros,
 ArrayUF, para reales
 ArrayUS, para strings, etc.
 Crear un tipo de dato súper general: Generico
 Modificar ArrayU para que sea un arreglo de cualquier tipo
de dato  un arreglo de genericos

18. TIPO DE DATO GENERICO
 Cualquier TDA que represente un conjuntos de datos,
tendrá este problema
 ¿De que tipo son esos elementos?
 Si lo definimos de un tipo especifico, nuestro TDA quedará muy
limitado
 ¿Qué podemos hacer?
 Abstraernos y crear un Tipo de Dato Generico
 Este nuevo TDA permitirá representar cualquier tipo de dato, sea
un entero, un real, u otro TDA

19. ¿Y COMO SE COMPORTARIA
UN GENERICO?
 La idea es lograr “almacenar” cualquier tipo de
dato dentro de una variable de tipo Generico
g g
 Una variable de tipo generico se puede crear
 Pero al hacerlo, habrá que especificar memoria para 4 6
que tipo de dato exactamente
 Esto dependerá del tipo del valor que va a almacenar
 También se le puede cambiar o consultar el g
valor que almacena Mama
Generico g;
g = CrearEntero(4);
g
CambiarEntero(g, 6);
g = CrearCadena(“Mama”); Papa
CambiarCadena(g, “Papa”);

20. GENERICO: NIVEL LOGICO
 Un tipo de dato Generico, debe permitir
 Crear un Generico, escondiendo un valor que cualquier tipo
 Generico g;
 g = CrearEntero(4);
 Eliminar una variable de tipo Generico
 Consultar y Modificar el valor escondido dentro
 Modificar el valor escondido, Ej. Con enteros
 SetEntero(G,5);
 Consultar el valor que el Generico almacena, Ej. Con Enteros
 valor = GetEntero(g);

21. GENERICO: NIVEL LOGICO
 ¿Qué representa el Generico?
 A cualquier tipo de dato, ya sea básico como compuesto
 Es decir
<generico> ::= <dato>
<dato> ::= <básico>|<compuesto>
<básico> ::= <int>|<float>|<double>|<char>|<string>
<compuesto>::= <arreglo>|<estructura>|<union>|<user_defined>

22. GENERICO: NIVEL DE
IMPLEMENTACION
 Que un valor sea Generico implica que
 No debe ser de ningún tipo al ser declarado
 Y dependiendo de quien lo use,
 En algún momento se “convertira” al tipo deseado
 Esto implicaría
 Reserva de memoria dinámica y
 Conversión explicita de un tipo a otro
 En lenguaje C
 El único tipo de dato que no es NADA es el void
 Entonces void * puede apuntar
a cualquier tipo de
 Una variable Generico, seria realmente de “tipo”: void * variable
 Que al inicio no es de ningún tipo

23. GENERICO: NIVEL DE
IMPLEMENTACION
 Operaciones
 Creación
 Generico Generico_CrearEntero(int valor);
 Eliminar
 Generico_Eliminar(Generico g);
 Modificar y Consultar
 void Generico_AsignarEntero(Generico g, int valor);
 int Generico_ObtenerEntero(Generico g);
 Declaración
 typedef void * Generico ;

24. GENERICO: EN C 1007
72
5
Generico g;
g = Generico_CrearInt(5); G
Generico_SetInt(g,Generico_GetInt(g)+67);
2056
printf(“%dn”, Generico_GetInt(g));
“Mama y Papa”
“Mama”
Generico_Eliminar(g);
g = Generico_CrearString(“Mama”);
strcpy(cad,Generico_GetString(g)); 1343
strcat(cad,” y Papa”); “Mama y Papa”
“Mama”
Generico_SetString(g, cad);
printf(“%dn”, Generico_GetString(g));
Generico_Eliminar(g);

25. GENERICO: NIVEL DE
APLICACION
 Bien utilizado
 El tipo de dato Generico puede ser sumamente útil
 A lo largo de todo el curso
 Para usarlo hay que considerar
 Nunca olvidar que las conversiones serán necesarias
 Si las dejamos a un lado, el resultado será no esperado ni
deseado

26. REDEFINICION DE ARRAYU
 Necesitamos redeclarar el TDA ArrayU
 Para definirlo como un arreglo de cualquier tipo de dato
 OJO: la definición en el nivel lógico sigue igual
 Solo cambiara el nivel de implementación
typedef struct{
Generico *Arreglo;
int nreal;
int inicial;
}ArrayU;

27. ARRAYU GENERICO: NIVEL DE
APLICACION
 Tratemos ahora de usar el ArrayU Generico
 Apliquémoslo en el mismo ejemplo anterior:
 Pedir n elementos por teclado, almacenarlos en un
arreglo y luego mostrar la mitad de cada valor ingresado

28. main(){
ArrayU *Datos;
int n, valor;
Generico g;
printf(¿Cuántos datos maximo desea ingresar?);
n = GetInteger();
Datos = ArrayU_Crear(n,1);
for(i = ArrayU_GetInicio(Datos); i <=ArrayU_GetFinal(Datos);i++){
//Inicio i en el for desde 1, no desde 0
printf(“Ingrese el dato No.”, i);
valor = GetInteger();
g = Generico_CrearEntero(valor);
ArrayU_SetElemento(Datos,i, g); //Pido el elemento i
}
for(i = 1; i <= Datos.n ; i++){
g = ArrayU_GetElemento(Datos,i);
valor= Generico_GetEntero(g)/2;
Generico_SetEntero(g, valor);
printf(“Mitad del elemento %d: “,
Generico_GetEntero(g));
}
ArrayU_Eliminar(&Datos);
}

29. VENTAJAS Y DESVENTAJAS
 Ventajas
 Logramos definir un arreglo mas funcional
 Siempre tiene consigo su tamaño, su índice inicial y
 Sirve para cualquier tipo de dato
 Ocultamos todos los detalles.. “la verdad”, detrás de la
abstracción
 Desventajas
 Como estamos muy acostumbrados al arreglo normal
 Este parece poco necesario

30. ARRAYU: AÑADIR MAS
COMPORTAMIENTO
 Podríamos en algunos caso,
 Desear que se imprima todo el arreglo por pantalla
 Pero habría un problema para implementar esta
herramienta
 Considerando que nuestro arreglo es Generico
 ¿Qué problema/s podrían surgir al tratar de hacer
esta herramienta?

31. LO QUE DESEAMOS
 Una herramienta que imprima un arreglo…
 Que no le importe el tipo
 Analicemos que necesita esta función para cumplir bien su
propósito
 Necesitaría el arreglo, para poder imprimirlo y…
 Pero como sabría como imprimir cada elemento???
 Cada elemento es Generico, ArrayU no conoce el tipo de dicho Generico,
y por lo tanto, no puede imprimirlo
 La función debería recibir :
 Un ArrayU, que es el que se desea imprimir
 Y “algo” que le indique como imprimir cada elemento del arreglo
 Pues desde dentro del TDA se desconoce como hacerlo

32. UNA PRIMERA SOLUCIÓN
 Que la función reciba una enumeracion que indique
de que tipo es el ArrayU
 void ArrayU_Imprimir(ArrayU *A, TipoDato tipo);
 En ese caso, la función debería elegir como imprimir el
arreglo, dependiendo del tipo:

33. void ArrayU_Imprimir(ArrayU *A, TipoDato tipo){
void ArrayU_Imprimir(ArrayU *A, TipoDato tipo){
for(i = 0; i< A->tmax; i++){
for(i = 0; i< A->tmax; i++){
switch(tipo){
switch(tipo){
int *valor_int;
int *valor_int;
char *cadena;
char *cadena;
Estudiante *E;
Estudiante *E;
Quebrado *Q;
Quebrado *Q;
case ENTERO:
case ENTERO:
valor_int = A-
valor_int = A-
>Elementos[i];
>Elementos[i];
printf(“%dn”,
printf(“%dn”,
*valor_int);
*valor_int);
break;
break;
case CADENA:
case CADENA:
cadena = A-
cadena = A-
>Elementos[i];
>Elementos[i];
printf(“%sn”,
printf(“%sn”,
cadena);
cadena);
break;
break;
case ESTUDIANTE:
case ESTUDIANTE:
E = A->Elementos[i];
E = A->Elementos[i];
Estudiante_Imprimir(E);
Estudiante_Imprimir(E);
break;
break;
case QUEBRADO:
case QUEBRADO:
Q = A->Elementos[i];
Q = A->Elementos[i];
Quebrado_Imprimir(Q);
Quebrado_Imprimir(Q);

34. DESVENTAJAS
 Son obvias:
 Esta función no sirve para cualquier tipo de dato
 Para que ArrayU soporte un nuevo tipo de dato hay que
modificar la función
 Buscar al creador del TDA
 Pedirle que añada un case para el nuevo tipo de dato
 Pedirle que recompile la librería
 Pedirle el nuevo .h y el nuevo .lib
 MUCHO TRABAJO!!
 Esta solución no favorece la expandibilidad del
TDA

35. SEGUNDA SOLUCIÓN
 Implementar la función igual que si conociera el tipo
de dato
 Enfocarnos en el algoritmo, no en el tipo de dato
 Pero.. Aquello que no sepamos como hacer
 Porque desconocemos el tipo de dato
 Lo debemos recibir como parametro
 Y no seria un valor
 Sería una acción una función, como parametro

36. void ArrayU_Imprimir(ArrayU *A, procfn Imprimir){
void ArrayU_Imprimir(ArrayU *A, procfn Imprimir){
for(i = 0; i< A->tmax; i++){
for(i = 0; i< A->tmax; i++){
//Imprimir A->Elementos[i], NO SE COMO
//Imprimir A->Elementos[i], NO SE COMO
HACERLO
HACERLO
//Llamo a la funcion Imprimir recibida
//Llamo a la funcion Imprimir recibida
como parametro
como parametro
Imprimir(A->Elementos[i]);
Imprimir(A->Elementos[i]);
}}
}}
void ImprimirEntero(int *valor);
void ImprimirEntero(int *valor);
void ImprimirCadena(char *cadena);
void ImprimirCadena(char *cadena);
void Estudiante_Imprimir(Estudiante *E);
void Estudiante_Imprimir(Estudiante *E);
void Quebrado_Imprimir(Quebrado *Q);
void Quebrado_Imprimir(Quebrado *Q);
main(){
main(){
ArrayU *A;
ArrayU *A;
A = ArrayU_Crear(10);
A = ArrayU_Crear(10);
//Se piden 10 Estudiante por teclado
//Se piden 10 Estudiante por teclado
//y se almacenan en A
//y se almacenan en A
ArrayU_Imprimir(A, Estudiante_Imprimir);
ArrayU_Imprimir(A, Estudiante_Imprimir);
}}

37. FUNCIONES CALLBACKS
 Es una herramientas de programación que nos ofrece
lenguaje C
 Permite crear un tipo de dato que describa una función
 En forma muy genérica
 Se indica tipo de dato de retorno
 Se indica los tipos de datos de entrada
 Ejemplo:
 typedef TipoRetorno (*Nombre_Nuevo_Tipo)(<valores de entrada>);
 Cualquier función que coincida con este prototipo
 Puede decirse que pertenece al nuevo tipo de dato declarado

38. EJEMPLO: LA GRAPHAPP
 El prototipo de la función que crea un nuevo botón es:
 button newbutton(char *text, rect r, actionfn fn);
 Recibe un texto, un rectángulo y al parecer una variable de tipo
actionfn
 Actionfn debe ser un nuevo tipo de dato, su declaración es:
 typedef void (*actionfn)(button b);
 Esto indica que cualquier función que coincida con el prototipo declarado para
actionfn será de tipo actionfn
 Ejemplo:
void CalcularSalarios(button b);
//….
button b;
b = newbutton(“Aceptar”, rect(10,10,10,10), CalcularSalarios);

39. SU UTILIDAD
 Ese mecanismo nos va a permitir
 Crear funciones que necesiten llamar a otras funciones
 Volviendo a nuestro caso,
 La función callback que necesitamos cumplirá la tarea de imprimir
un dato Generico:
 typedef void (*Generico_Imprimir)(Generico);
 Cualquier función que tenga este prototipo caerá en este tipo.
Ejemplo:
 void Imprimir_Entero(int *a); o
 void Imprimir_String(char *s);

40. USANDO UNA FUNCION
COMO PARAMETRO
 Nuestra función para imprimir un ArrayU quedaría entonces
 void ArrayU_Imprimir(ArrayU *A, Generico_Imprimir fn);
 La implementación de esta función quedaría algo como:
void ArrayU_Imprimir(ArrayU *A, Generico_Imprimir fn){
int i;
for(i = 0; i < A->nreal;i++){
fn(ArrayU_ElemC(A,i););
}
}

41. LLAMANDO A LA IMPRESION
void Imprimir_Entero(int *valor);
main(){
ArrayU *Datos;
int n, valor;
Generico g;
printf(¿Cuántos datos maximo desea ingresar?);
n = GetInteger();
Datos = ArrayU_Crear(n,1);
for(i = ArrayU_Inicio(Datos); i <= ArrayU_Final(Datos) ;i++){
printf(“Ingrese el dato No.”, i);
valor = GetInteger();
g = Generico_CrearInt(valor/2);
ArrayU_SetElementos(Datos,i,g);
}
ArrayU_Imprimir(Datos, Imprimir_Entero);
ArrayU_Eliminar(&Datos);
}
void Imprimir_Entero(int *valor){
printf(“%d”, *valor);
}

42. VENTAJAS DEL CALLBACK
 Puedo definir funciones “genericas”
 A través de la definición de tipos de datos de funciones
 Son útiles cuando un procedimiento que se
ejecutará es variable en el problema
 Todos los procedimientos posibles de llamar
 Deben tener el prototipo en común