free_sized

 

C

Compiler-Unterstützung

Sprache

Header

Typunterstützung

Programm-Dienstprogramme

Unterstützung für variable Funktionsargumente

Fehlerbehandlung

Dynamische Speicherverwaltung

Bibliothek für Zeichenketten

Algorithmen

Numerik

Datums- und Zeitdienstprogramme

Ein-/Ausgabeunterstützung

Lokalisierungsunterstützung

Unterstützung für Nebenläufigkeit (C11)

Technische Spezifikationen

Symbolindex

 

Dynamische Speicherverwaltung

malloc

calloc

realloc

free

free_sized (C23)

free_aligned_sized (C23)

aligned_alloc (C11)

 

Definiert im Header <stdlib.h>
void free_sized( void* ptr, size_t size );		(seit C23)

Gibt den Speicher frei, der zuvor von malloc(), calloc() oder realloc() zugewiesen wurde (aber nicht von aligned_alloc()).

free_sized ist threadsicher: Es verhält sich so, als ob nur auf die Speicherstellen zugegriffen wird, die über das Argument sichtbar sind, und nicht auf statische Speicher.

Ein Aufruf von free_sized, der einen Speicherbereich freigibt, *synchronisiert* mit einem Aufruf einer beliebigen nachfolgenden Speicherzuweisungsfunktion, die denselben Speicherbereich oder einen Teil davon zuweist. Diese Synchronisation erfolgt nach jedem Zugriff auf den Speicher durch die freigebende Funktion und vor jedem Zugriff auf den Speicher durch die Zuweisungsfunktion. Es gibt eine einzige Gesamtordnung für alle Speicherzuweisungs- und Freigabefunktionen, die auf einen bestimmten Speicherbereich wirken.

Parameter

ptr	-	Zeiger auf den freizugebenden Speicher
size	-	Größe des Speichers, der zuvor an eine Zuweisungsfunktion übergeben wurde

Rückgabewert

(keine)

Mögliche Implementierung

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

Beispiel

Führen Sie diesen Code aus

#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
 
typedef struct
{
    size_t size;     // current number of elements
    size_t capacity; // reserved number of elements
    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);
}

Ausgabe

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

Referenzen

• C23-Standard (ISO/IEC 9899:2024)

• 7.24.3.4 Die Funktion free_sized (S. 365-366)

Siehe auch

free	dealloziert zuvor allozierten Speicher (Funktion)
free_aligned_sized (C23)	dealloziert zuvor allozierten Speicher mit Größe und Ausrichtung (Funktion)
malloc	alloziert Speicher (Funktion)