Sets (punteros)

Funciones

Al igual que vimos los ArrPt, el tipo SetPt son contenedores tipo set (basados en binary search trees) pero que contienen punteros en lugar de objetos completos. Por tanto, sirve todo lo visto en Sets, salvo por la necesidad de tener que crear y liberar la memoria que ocupa cada objeto, ya que en el contenedor solo existirá un puntero al mismo (Figura 1). La decisión de utilizar SetSt o SetPt dependerá de cada caso, pero los motivos serán prácticamente los mismos que condicionaban la elección entre ArrSt y ArrPt.

• Si se mantienen referencias externas a los elementos, utilizar SetPt.
• Si alojamos objetos opacos, utilizar SetPt.

1. Crear sets de punteros

• Utiliza setpt_create para crear un set.
• Utiliza setpt_destroy para destruir el set y sus elementos.
• Utiliza setpt_insert para insertar un elemento.

La principal diferencia con respecto a los SetSt radica en la inserción y eliminación de objetos. Esta vez setpt_insert() no devolverá la dirección de memoria del objeto insertado, sino un booleano indicando si la inserción ha sido posible o no (Listado 1). Por su lado, el destructor debe liberar la memoria del objeto en sí, además de la memoria reservada para cada campo del objeto.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

typedef struct _product_t Product;
struct _product_t
{
    type_t type;
    String *code;
    String *desc;
    Image *image;
    real32_t price;
};

static void i_destroy(Product **prod)
{
    str_destroy(&(*prod)->code);
    str_destroy(&(*prod)->desc);
    image_destroy(&(*prod)->image);
    heap_delete(prod, Product);
}

static int i_compare(const Product *prod, const char_t *code)
{
    return str_cmp(prod->code, code);
}

SetPt(Product) *products = setpt_create(i_compare, Product, char_t);
...
Product *prod = heap_new(Product);
prod->type = ekHDD;
prod->code = str_c("GTK-1050");
prod->desc = str_c("Gigabyte GeForce GTX 1050 OC 2Gb GDDR5");
prod->image = load_image("card.png");
prod->price = 573.34;
if (setpt_insert(products, "GTK-1050", prod, Product, char_t) == FALSE)
{
    // Insert error
    i_destroy(&prod);
}
...
setpt_destroy(&products, i_destroy, Product);

setpt_create ()

Crea un set de punteros vacío.

SetPt(type)*
setpt_create(FPtr_compare func_compare,
             type,
             ktype);

Retorna

El nuevo set.

Observaciones

Ver Crear sets de punteros.

setpt_destroy ()

Destruye un set y todos sus elementos.

void
setpt_destroy(SetPt(type) **set,
              FPtr_destroy func_destroy,
              type);

setpt_size ()

Obtiene el número de elementos del set.

uint32_t
setpt_size(const SetPt(type) *set,
           type);

Retorna

Número de elementos.

setpt_get ()

Busca un elemento en O(logn). Si existe, el iterador interno quedará fijado en él.

type*
setpt_get(SetPt(type) *set,
          const ktype *key,
          type,
          ktype);

Retorna

Puntero al elemento si existe, o NULL si no.

Observaciones

Ver Búsqueda y recorrido en sets. Iteradores.

setpt_get_const ()

Versión const de setpt_get.

const type*
setpt_get_const(const SetPt(type) *set,
                const ktype *key,
                type,
                ktype);

Retorna

Elemento.

setpt_insert ()

Inserta un nuevo elemento en el set.

bool_t
setpt_insert(SetPt(type) *set,
             const ktype *key,
             type *ptr,
             type,
             ktype);

Retorna

TRUE si el elemento ha sido insertado. FALSE si ya existe otro elemento con la misma clave.

Observaciones

Insertar o eliminar elementos invalida el iterador interno del set. Debes volver a inicializarlo con setpt_first o similares.

setpt_delete ()

Elimina un elemento del set.

bool_t
setpt_delete(SetPt(type) *set,
             type *key,
             FPtr_destroy func_destroy,
             type,
             ktype);

Retorna

TRUE si el elemento ha sido eliminado, o FALSE si no existe un elemento con dicha clave.

Observaciones

Insertar o eliminar elementos invalida el iterador interno del set. Debes volver a inicializarlo con setpt_first o similares.

setpt_first ()

Obtiene el primer elemento del set e inicializa el iterador interno.

type*
setpt_first(SetPt(type) *set,
            type);

Retorna

Puntero al primer elemento o NULL si el set está vacío.

Observaciones

Ver Búsqueda y recorrido en sets. Iteradores.

setpt_first_const ()

Versión const de setpt_first.

const type*
setpt_first_const(const SetPt(type) *set,
                  type);

Retorna

Elemento.

setpt_last ()

Obtiene el último elemento del set e inicializa el iterador interno.

type*
setpt_last(SetPt(type) *set,
           type);

Retorna

Puntero al último elemento o NULL si el set está vacío.

Observaciones

Ver Búsqueda y recorrido en sets. Iteradores.

setpt_last_const ()

Versión const de setpt_last.

const type*
setpt_last_const(const SetPt(type) *set,
                 type);

Retorna

Elemento.

setpt_next ()

Obtiene el siguiente elemento del set, tras incrementar el iterador interno.

type*
setpt_next(SetPt(type) *set,
           type);

Retorna

Puntero al siguiente elemento o NULL si el iterador ha alcanzado el último.

Observaciones

Utiliza setpt_first para inicializar el iterador interno.

setpt_next_const ()

Versión const de setpt_next.

const type*
setpt_next_const(const SetPt(type) *set,
                 type);

Retorna

Elemento.

setpt_prev ()

Obtiene el elemento anterior del set, tras decrementar el iterador interno.

type*
setpt_prev(SetPt(type) *set,
           type);

Retorna

Puntero al elemento anterior o NULL si el iterador ha alcanzado el primero.

Observaciones

Utiliza setpt_last para inicializar el iterador interno en recorridos revertidos.

setpt_prev_const ()

Versión const de setpt_prev.

const type*
setpt_prev_const(const SetPt(type) *set,
                 type);

Retorna

Elemento.

setpt_foreach ()

Recorre todos los elementos del set. Utiliza setpt_fornext para cerrar el bucle.

void
setpt_foreach(type *elem,
              SetPt(type) *set,
              type);

setpt_foreach_const ()

Versión const de setpt_foreach.

void
setpt_foreach_const(const type *elem,
                    const SetPt(type) *set,
                    type);

setpt_fornext ()

Cierra el bucle abierto por setpt_foreach, incrementando el iterador interno.

void
setpt_fornext(type *elem,
              SetPt(type) *set,
              type);

setpt_fornext_const ()

Versión const de setpt_fornext.

void
setpt_fornext_const(const type *elem,
                    const SetPt(type) *set,
                    type);

setpt_forback ()

Recorre todos los elementos del set en orden inverso. Utiliza setpt_forprev para cerrar el bucle.

void
setpt_forback(type *elem,
              SetPt(type) *set,
              type);

setpt_forback_const ()

Versión const de setpt_forback.

void
setpt_forback_const(const type *elem,
                    const SetPt(type) *set,
                    type);

setpt_forprev ()

Cierra el bucle abierto por setpt_forback, decrementando el iterador interno.

void
setpt_forprev(type *elem,
              SetPt(type) *set,
              type);

setpt_forprev_const ()

Versión const de setpt_forprev.

void
setpt_forprev_const(const type *elem,
                    const SetPt(type) *set,
                    type);