*** glibc detected *** double free or corruption (!prev): 0x0804b008 ***

[fibergran]

inse100.C



/************************************************** **********
************************************************** ************
contenidos:
- Implementacion de int_set_100
- Implementacion de int_set_100_it


************************************************** ************

creacion: 8-03-96 (miguel vega)

modificaciones:

1) fecha (autor): 08-03-06 (Jaime Fuentes Pérez)

motivo: En la clase int_set_100, la función insert
devuelve el mismo valor cuando inserta el elemento
y cuando la tabla está llena, no es lo mismo que se
halla insertado bien el
elemento a que no se halla insertado bien.

mejoras: Añadir que cuando la tabla este llena devuelva
-1, quedando entonces:
-1 -> Tabla llena
0 -> El elemento ya pertenecia al conjunto
1 -> El elemento se inserto correctamente

2) fecha (autor): 21-03-06 (Jaime Fuentes Pérez)

motivo: En la funcion drop, borra la primera instancia
de ele que encuentra en el conjunto, y ya está.

mejora: Se ha hecho que se borre el elemento y se
desplacen todos una posición anterior, y se
decrementa cursize.

__________________________________________________ _

modificaciones práctica 2:

1) fecha (autor): 30-03-06 (Jaime Fuentes Pérez)

motivo: Con la clase anterior no se podían usar conjuntos de más
de 100 elementos

mejoras: Se utiliza memoria dinámica en el constructor, a la vez se crea
un destructor y se incluye este en el fichero cabecera intset.h
Además se incluye una variable maxsize como componente de la clase
con el objetivo de guardar la cantidad de memoria reservada para el
conjunto con la finalidad de hacer una clase mas eficiente en la reserva
de dicha memoria.

2) fecha (autor): 30-03-06 (Jaime Fuentes Peŕez)

motivo: Se busca más eficiencia en el insert de manera que no haya que
preguntar si el elemento a insertar ya existe en el conjunto. También
se busca la eficiencia en el drop.

mejoras: Se hace que en el insert unicamente se añada el elemento, indepen-
dientemente si ya estaba dentro o no, ademas de añadir a la función,
una parte en la que se reserve más memoria para el conjunto es el caso de
que ya esté llena la memoria reservada.

En el caso del drop, se busca primero un elemento distinto a ele
(elemento que se quiere eliminar), si no hay un elemento distinto a ele
significará que ele es el único elemento del conjunto (aunque puede estar
repetido), en este caso bastaría con poner cursize a 0. En el caso de que
exista un elemento distinto a ele, pondríamos este elemento en cada posición
en la que encontremos a ele.

3) fecha (autor): 06-04-06 (Jaime Fuentes Pérez)

motivo: Como pueden existir elementos repetidos dentro del vector, y con el
fin de utilizar el vector como un conjunto, necesitamos una fución que
nos de una posición ĺógica de cualquier elemento dentro del conjunto.

mejoras: Se añade una función miembro a la clase (indice) que se encargará de
devolver la posición lógica de ele dentro de el vector. La función es la
misma que index, aunque antes debemos de ordenar el conjunto

4) fecha (autor): 11-04-06 (Jaime Fuentes Pérez)

motivo: Como pueden existir elementos repetidos dentro del vector, y con el
fin de utilizar el vector como un conjunto, la función size, debe devolver
el tamaño lógico del conjunto, dado que un conjunto con los elementos:
<1 3 5 3 4 7> tendría 5 elementos y no 6.

mejora: A la función size le hacemos que elimine los elementos repetidos del
vector antes de devolver el tamaño del conjunto. Para esto crea un vector
auxiliar donde se copian todos los elementos del principal, y va metiendo
los elementos del vector auxiliar al principal dejando fuera los elementos
repetidos.

************************************************** ************
************************************************** ***********/
/************************************************** *****************

Implementacion:

Tad: int_set_100

Representacion:
Rep = int_set_100 data members:
{int cursize;
int maxsize;
int members[100];}
Rep r;

F.Abstraccion: r representa al conjunto de todos
los valores enteros de los primeros r.cursize
elementos de r.members y r.maxsize contiene
el numero de posicones reservadas para el
conjunto.

I.Representacion: entre los primeros r.cursize valores de
r.members no hay repeticiones

Descripcion:


Operaciones internas:
************************************************** *******************

Interface: int index(int ele)


requer.:
modif.:
efecto: si ele es uno de los valores contenidos en el array
devuelve el indice correspondiente, en caso contrario
devuelve el valor int(-1)


************************************************** *******************

Uso: is100pru.C contiene un ejemplo de uso

************************************************** *******************/
#include "intset.h"
#include <iostream.h>

int_set_100::int_set_100(){
cursize = 0;
members = new int [50];
maxsize = 50;
}

int_set_100::~int_set_100 () {
delete [] members;
}

int int_set_100::index(int ele){
for(int i = 0; i<cursize; i++) {
if (members[i] == ele)
return i;
}
return -1;
}

int int_set_100::insert(int ele){

if (cursize > maxsize) {
int* aux = members;
maxsize += 50;
members = new int [maxsize];
for (int i=0; i<cursize; i++)
members[i] = aux[i];
delete [] aux;
}



members[cursize++] = ele;
return 1;
}

int int_set_100::drop(int ele){
int i;
if ( index(ele) == -1)
return 0; //Si ele no esta ya sta to exo

// Busca dentro del conj un elem != a ele

int aux = 0;
bool modif_aux = false;
for (int z=0; (z < cursize) && (modif_aux == false); z++)
if (members [z] != ele){ //si encuentra un elem != ele salimos
modif_aux = true; //si no, seguimos hasta el final
aux = members [z];
}

// Reemplaza ele con aux
if (modif_aux == true)
while ( (i=index (ele)) != -1 ) {
members [i] = aux;
}

else //si modif_aux es true es xq solo queda un elem en el conj
cursize = 0;

return 1;
};

int int_set_100::member(int ele)
{return (index(ele) != -1);};

int int_set_100::size() {


int *aux;
int aux_cursize = cursize;
aux = new int [cursize];
for (int i=0; i < cursize; i++)
aux [i] = members [i]; //conj aux = a this

cursize = 0; // vaciamos el conj

//se insertan en el conj los elems sin repetir
for (int h=0; h< aux_cursize; h++)
if ((member (aux [h])) != 1) {
members [cursize] = aux [h];
cursize++;
}
delete [] aux;


return cursize;
};

int int_set_100::indice (int ele) {
int aux = size (); // para ordenar los elems del conjunto
for(int i = 0; i<cursize; i++) {
if (members[i] == ele)
return i;
}
return -1;

};
/************************************************** ******************

Implementacion:

Tad: int_set_100_it

Representacion:

Rep = int_set_100_it data members:

{int_set_100 set;int currindex;}

Rep r;


F.Abstraccion:

I.Representacion: una vez inicializado, al crear el objeto, set
no se modifica

Descripcion:


Operaciones internas:


Uso: is100pru.C contiene un ejemplo de uso

************************************************** *******************/


int_set_100_it::int_set_100_it (int_set_100 & aSet){
set = aSet;
currindex = 0;};

int int_set_100_it::operator++(int) {
return set.members[currindex++];
};

int int_set_100_it::atEnd() {
return (currindex == set.cursize);
};