enunciado de la práctica 7

PARADIGMAS DE PROGRAMACIÓN
Grado en Ingeniería Informática
Curso 2011/12
PRÁCTICA 7 (Vector Dinámico)
OBJETIVO: Se desea implementar en un fichero “vectordinamico.ml” una clase VectorDinamico para gestionar un vector cuyo tamaño aumenta según se van añadiendo elementos (enteros). Internamente se implementa mediante un array. El vector depende de un parámetro tamBloque que indica en cuánto crece el espacio disponible una vez que hemos agotado el actual. Como ejemplo, si tamBloque=5, y añadimos uno a uno al vector los elementos "a", "b", "c", "d", "e", "f", daría lugar a la secuencia de estados:
Vista lógica
[]
Vista interna
[,_,_,_,_,_] Inicialmente el vector está vacío (i.e. contiene 0 elementos), pero tiene ya espacio disponible para tamBloque=5 elementos. Ahora según se van añadiendo elementos, éste se va llenando.
[a]
[a,_,_,_,_] [a,b]
[a,b,_,_,_] [a,b,c]
[a,b,c,_,_] [a,b,c,d]
[a,b,c,d,_] [a,b,c,d,e]
[a,b,c,d,e]
En este punto se ha agotado el espacio del primer bloque, por lo que si queremos insertar un nuevo elemento es preciso ampliar previamente la estructura aumentando el espacio disponible en tamBloque=5 posiciones más. [a,b,c,d,e,f]
[a,b,c,d,e,f,_,_,_,_] Si inserto un elemento por en medio de los elementos (p.ej. inserto “X” en la posición 2), deberé hacerle hueco desplazando hacia la derecha los elementos de esa posición en adelante.
[a,b,X,c,d,e,f] [a,b,X,c,d,e,f,_,_,_] Actualmente el vector contiene 7 elementos con espacio para 10.
ATRIBUTOS Y MÉTODOS DE LA CLASE:
(* ­­­ Constructor ­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­
Al hacer new se pasara como unico parametro el tamano de bloque deseado, inicializandose la estructura devuelta a un vector dinamico vacio de tamano­de­bloque elementos. *)
(* ­­­ Atributos ­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­ *)
(* Estructura de almacenamiento de los elementos del vector.
buffer: int array *)
(* Numero de elementos que contiene actualmente el vector.
numEltos: int *)
(* Tamano de bloque.
tb: int *)
(* ­­­ Metodos de modificacion ­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­ *)
(* Anadir un elemento al final del vector actual.
annade: int → unit *)
(* Insertar en la posicion i (1er argumento) del vector actual un elemento dado (2o argumento) desplazando en una posicion a la derecha todos los elementos desde el i­esimo hasta el ultimo. Si la posicion no es valida se lanza una excepcion Invalid_argument "index out of bounds".
inserta: int → int → unit *)
(* Sobreescribir la posicion i (1er argumento) con un elemento dado (2o argumento). No cambia el numero total de elementos. Si la posicion no es valida se lanza una excepcion Invalid_argument "index out of bounds". sobreescribe: int → int → unit *)
(* ­­­ Metodos de consulta ­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­ *)
(* Devolver la longitud actual del vector, es decir, el numero de elementos almacenados.
longitud: unit → int *)
(* Devolver el i­esimo elemento del vector. Si la posicion no es valida se lanza una excepcion Invalid_argument "index out of bounds".
elemento: int → int *)
(* Devolver la primera posicion por la izquierda en la que aparece un elemento dado. Si no estuviera en el array, entonces devuelve ­1 sin mas. indice: int → int
(* Imprimir el contenido del vector en un string (i.e. sólo imprime la parte que contiene elementos) to_string: unit → string *)
(* Imprimir el contenido de la estructura de almacenamiento del vector en un string (i.e. imprime tanto la parte que contiene elementos como la que no contiene elementos)
to_stringBuffer: unit → string *)
EJEMPLO DE EJECUCIÓN:
# #use "vectordinamico.ml";;
class vectordinamico :
int ­>
object
val mutable buffer : int array
val mutable numEltos : int
val tb : int
method annade : int ­> unit
method elemento : int ­> int
method indice : int ­> int
method inserta : int ­> int ­> unit
method longitud : unit ­> int
method sobreescribe : int ­> int ­> unit
method to_string : unit ­> string
method to_stringBuffer : unit ­> string
end
# let prueba = new vectordinamico 5;;
val prueba : vectordinamico = <obj>
# prueba#longitud();;
­ : int = 0
# prueba#to_string();;
­ : string = "[]"
# prueba#to_stringBuffer();;
­ : string = "[_,_,_,_,_]"
# prueba#annade 10;;
­ : unit = ()
# prueba#longitud();;
­ : int = 1
# prueba#to_string();;
­ : string = "[10]"
# prueba#to_stringBuffer();;
­ : string = "[10,_,_,_,_]"
# prueba#annade 30;;
­ : unit = ()
# prueba#annade 40;;
­ : unit = ()
# prueba#inserta 4 20;;
Exception: Invalid_argument "index out of bounds".
# prueba#inserta 1 20;;
­ : unit = ()
# prueba#longitud();;
­ : int = 4
# prueba#to_string();;
­ : string = "[10,20,30,40]"
# prueba#to_stringBuffer();;
­ : string = "[10,20,30,40,_]"
# prueba#annade 50;;
­ : unit = ()
# prueba#to_string();;
­ : string = "[10,20,30,40,50]"
# prueba#to_stringBuffer();;
­ : string = "[10,20,30,40,50]"
# prueba#annade 60;;
­ : unit = ()
# prueba#to_string();;
­ : string = "[10,20,30,40,50,60]"
# prueba#to_stringBuffer();;
­ : string = "[10,20,30,40,50,60,_,_,_,_]"
# prueba#sobreescribe 1 22;;
­ : unit = ()
# prueba#to_string();;
­ : string = "[10,22,30,40,50,60]"
# prueba#to_stringBuffer();;
­ : string = "[10,22,30,40,50,60,_,_,_,_]"
# prueba#sobreescribe 100 100;;
Exception: Invalid_argument "index out of bounds".
# prueba#elemento 7;;
Exception: Invalid_argument "index out of bounds".
# prueba#elemento 1;;
­ : int = 22
# prueba#indice 30;;
­ : int = 2
# prueba#indice 100;;
­ : int = ­1
# prueba#indice 0;;
­ : int = ­1