sobre listas enlazadas

[Guillermo]

Hola
Estoy trabajando en un programa el usa listas enlazadas. Hice mi propia
libreria con todas las operaciones sobre listas que necesitaba, como
por ejemplo insertar_elem, delete_elem, etc. La libreria funciona para
un tipo de dato especifico, un struct de mi programa. Ahora necesito
manejar listas para otro tipo de datos de mi programa. Lo usual es que
si se desea tener una libreria de operaciones de listas que sirva para
todo tipo de datos, entoces se hace que ella maneje apuintadores a void
(void *). De esta manera no se duplica codigo teniendo que escribir
funciones homologas para cada tipo de datos. El problema con tener una
libreria que trabaje con (void *) es que es, segun la literatura, es
menos eficiente que hacer las operaciones con el tipo de dato con que
se desea trabajar. Mi pregunta es ¿que tan cierto es esto?. Mi
programa tiene muy eficiente, pero no se si vale la pena escribir el
mismo codigo de las operaciones de listas para otro tipo de dato.
Gracias por sus opiniones

Guillermo

[J.A. Gutierrez]

Guillermo <***@yahoo.com> wrote:
: todo tipo de datos, entoces se hace que ella maneje apuintadores a void
: (void *). De esta manera no se duplica codigo teniendo que escribir
: funciones homologas para cada tipo de datos. El problema con tener una
: libreria que trabaje con (void *) es que es, segun la literatura, es
: menos eficiente que hacer las operaciones con el tipo de dato con que

no me queda muy clara la cuestion.
Si te refieres a que es menos eficiente que los datos de
la lista sean punteros (ya sean void* o sean de cualquier
otro tipo) en lugar de directamente el dato final, es evidente
que si que pierdes eficiencia (hay un nivel mas de indireccion).

Pero si duplicas todo el codigo de las listas, tambien
puedes perder eficiencia (el proceso ocupara mas memoria).

Otra alternativa puede ser que los datos sean un buffer
de tama~no fijo (superior al maximo que pienses usar) donde
metas tu informacion y luego la interpretas como quieras.

[Pedro Maicas]

Post by Guillermo
funciones homologas para cada tipo de datos. El problema con tener una
libreria que trabaje con (void *) es que es, segun la literatura, es

pues yo no me lo creo, por mucho que lo diga la literatura,
la eficiencia dependerá de otras cosas,como de la necesidad
-o no- de copiar elementos (esturcturas), si manejas solo punteros
te da lo mismo qué tipo de puntero sea, solo que resulta un c*ñazo
tener que hacer cada vez un cast del puntero, pero el cast se resuelve
durante la compilacion, no genera código y por lo tanto el codigo
máquina es idéntico sea cual sea el tipo apuntado por el puntero.


Saludos :-) -Pedro-

http://www.maicas.net/

e-mail en www.maicas.net

[heltena]

No tienes por qué utilizar void *, puedes decidir usar un void * y un
parámetro extra de longitud y copiar esa info en la estructura del
nodo. Escribiendo de memoria:

struct nodo_t {
struct nodo_t *prev, *next;
/* se reservará más memoria según el tamaño del item */
};

struct lista_t {
struct nodo_t *first, *last;
};

insertar_elem(struct lista_t *pl, void *pitem, int len) {
struct nodo_t *n = (struct nodo_t *) malloc(sizeof(struct nodo_t) +
len);
assert(pl);
assert(n);
n->next = NULL;
n->prev = pl->last;
if (pl->last != NULL)
pl->last->prev = n;
pl->last = n;
if (len > 0)
memcpy(n + sizeof(struct nodo_t), pitem, len);
}

void get_tail(struct lista_t *pl, void *pitem, int len) {
assert(pl);
if (pl->last != NULL) {
assert(pitem);
memcpy(pitem, pl->last + sizeof(struct nodo_t), len);
}
}

Creo que esta es una implementación muy aproximada que generaliza la
que ya tienes.

Y si lo piensas un poco, en cada nodo puedes guardar un elemento de
tamaño variable (puedes guardar el campo longitud dentro de la
estructura del nodo y hasta un entero para identificar de qué tipo es
... me recuerda sospechosamente al señor polimorfismo).

Hasta pronto!!!!