free_sized

Libère l'espace précédemment alloué par malloc() , calloc() , ou realloc() (mais pas aligned_alloc() ).

free_sized est sûr pour les threads : il se comporte comme s'il n'accédait qu'aux emplacements de mémoire visibles via son argument, et non à un stockage statique.

Un appel à free_sized qui désalloue une région de mémoire synchronise-avec un appel à toute fonction d'allocation ultérieure qui alloue la même région ou une partie de la même région de mémoire. Cette synchronisation se produit après tout accès à la mémoire par la fonction de désallocation et avant tout accès à la mémoire par la fonction d'allocation. Il existe un ordre total unique pour toutes les fonctions d'allocation et de désallocation opérant sur chaque région de mémoire particulière.

Paramètres

Valeur de retour

(aucun)

Notes

Implémentation possible

void free_sized(void* ptr, size_t /*taille*/)
{
    free(ptr);
}

Exemple

#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct
{
    size_t size;     // nombre actuel d'éléments
    size_t capacity; // nombre réservé d'éléments
    void** data;
} PtrVector;
PtrVector vector_create(size_t initial_capacity)
{
    PtrVector ret =
    {
        .capacity = initial_capacity,
        .data = (void**) malloc(initial_capacity * sizeof(void*))
    };
    return ret;
}
void vector_delete(PtrVector* self)
{
    free_sized(self->data, self->capacity * sizeof(void*));
}
void vector_push_back(PtrVector* self, void* value)
{
    if (self->size == self->capacity)
    {
        self->capacity *= 2;
        self->data = (void**) realloc(self->data, self->capacity * sizeof(void*));
    }
    self->data[self->size++] = value;
}
int main()
{
    int data = 42;
    float pi = 3.141592f;
    PtrVector v = vector_create(8);
    vector_push_back(&v, &data);
    vector_push_back(&v, &pi);
    printf("data[0] = %i\n", *(int*)v.data[0]);
    printf("data[1] = %f\n", *(float*)v.data[1]);
    vector_delete(&v);
}

data[0] = 42
data[1] = 3.141592

Références

Voir aussi