std:: realloc

Weist den angegebenen Speicherbereich neu zu ( implizit Objekte erzeugend im Zielbereich). Er muss zuvor durch std::malloc , std::calloc oder std::realloc alloziert und noch nicht mit std::free freigegeben worden sein, andernfalls sind die Ergebnisse undefiniert.

Die Neuzuweisung erfolgt entweder durch:

Wenn nicht genügend Speicher vorhanden ist, wird der alte Speicherblock nicht freigegeben und ein null-Zeiger zurückgegeben.

Wenn ptr ein Nullzeiger ist, ist das Verhalten dasselbe wie beim Aufruf von std:: malloc ( new_size ) .

Wenn new_size null ist, ist das Verhalten implementierungsdefiniert: Es kann ein null-Zeiger zurückgegeben werden (wobei der alte Speicherblock freigegeben werden kann oder nicht) oder es kann ein nicht-null-Zeiger zurückgegeben werden, der möglicherweise nicht zum Zugriff auf Speicher verwendet werden darf. Eine solche Verwendung ist veraltet (durch C DR 400 ). (seit C++20)

Parameter

Rückgabewert

Bei Erfolg gibt die Funktion einen Zeiger auf den Anfang des neu zugewiesenen Speichers zurück. Um einen Speicherverlust zu vermeiden, muss der zurückgegebene Zeiger mit std::free oder std::realloc freigegeben werden. Der ursprüngliche Zeiger ptr wird ungültig und jeglicher Zugriff darauf ist undefined behavior (selbst wenn die Neuzuweisung in-place erfolgte).

Bei Fehler wird ein Nullzeiger zurückgegeben. Der ursprüngliche Zeiger ptr bleibt gültig und muss möglicherweise mit std::free freigegeben werden.

Hinweise

Da die Neuzuordnung byteweises Kopieren beinhalten kann (unabhängig davon, ob der Bereich erweitert oder verkleinert wird), ist es notwendig (aber nicht ausreichend), dass diese Objekte vom Typ TriviallyCopyable sind.

Einige nicht-standardisierte Bibliotheken definieren ein Typ-Merkmal "BitwiseMovable" oder "Relocatable", das einen Typ beschreibt, der nicht über folgende Eigenschaften verfügt:

• externe Referenzen (z.B. Knoten einer Liste oder eines Baums, die auf ein anderes Element verweisen), und
• interne Referenzen (z.B. Member-Zeiger, die möglicherweise die Adresse eines anderen Members enthalten).

Objekte dieses Typs können auch dann aufgerufen werden, nachdem ihr Speicher neu zugewiesen wurde, selbst wenn ihre Kopierkonstruktoren nicht trivial sind.

Beispiel

#include <cassert>
#include <cstdlib>
#include <new>
class MallocDynamicBuffer
{
    char* p;
public:
    explicit MallocDynamicBuffer(std::size_t initial = 0) : p(nullptr)
    {
        resize(initial);
    }
    ~MallocDynamicBuffer() { std::free(p); }
    void resize(std::size_t newSize)
    {
        if (newSize == 0) // diese Prüfung ist nicht zwingend erforderlich,
        {
            std::free(p); // aber Realloc mit Nullgröße ist in C veraltet
            p = nullptr;
        }
        else
        {
            if (void* mem = std::realloc(p, newSize))
                p = static_cast<char*>(mem);
            else
                throw std::bad_alloc();
        }
    }
    char& operator[](size_t n) { return p[n]; }
    char operator[](size_t n) const { return p[n]; }
};
int main()
{
    MallocDynamicBuffer buf1(1024);
    buf1[5] = 'f';
    buf1.resize(10); // verkleinern
    assert(buf1[5] == 'f');
    buf1.resize(1024); // vergrößern
    assert(buf1[5] == 'f');
}

Siehe auch