std:: realloc

Réalloue la zone de mémoire donnée ( en créant implicitement des objets dans la zone de destination). Elle doit avoir été préalablement allouée par std::malloc , std::calloc ou std::realloc et ne pas encore avoir été libérée avec std::free , sinon, les résultats sont indéfinis.

La réallocation est effectuée par l'une des méthodes suivantes :

S'il n'y a pas assez de mémoire, le bloc de mémoire ancien n'est pas libéré et un pointeur nul est retourné.

Si ptr est un pointeur nul, le comportement est le même que celui de l'appel à std:: malloc ( new_size ) .

Si new_size est zéro, le comportement est défini par l'implémentation : un pointeur nul peut être retourné (auquel cas l'ancien bloc mémoire peut être libéré ou non) ou un pointeur non nul peut être retourné qui ne peut pas être utilisé pour accéder au stockage. Un tel usage est déprécié (via C DR 400 ). (depuis C++20)

Paramètres

Valeur de retour

En cas de succès, retourne un pointeur vers le début de la mémoire nouvellement allouée. Pour éviter une fuite mémoire, le pointeur retourné doit être désalloué avec std::free ou std::realloc . Le pointeur original ptr est invalidé et tout accès à celui-ci constitue un comportement indéfini (même si la réallocation s'est faite en place).

En cas d'échec, retourne un pointeur nul. Le pointeur original ptr reste valide et pourrait nécessiter une désallocation avec std::free .

Notes

Parce que la réallocation peut impliquer une copie octet par octet (qu'elle étende ou réduise la zone), il est nécessaire (mais pas suffisant) que ces objets soient de type TriviallyCopyable .

Certaines bibliothèques non standard définissent un trait de type "BitwiseMovable" ou "Relocatable", qui décrit un type qui ne possède pas :

• références externes (par exemple, les nœuds d'une liste ou d'un arbre qui contiennent une référence à un autre élément), et
• références internes (par exemple, un pointeur membre qui pourrait contenir l'adresse d'un autre membre).

Les objets de ce type peuvent être consultés après que leur stockage a été réalloué, même si leurs constructeurs de copie ne sont pas triviaux.

Exemple

#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) // cette vérification n'est pas strictement nécessaire,
        {
            std::free(p); // mais realloc de taille zéro est déprécié en C
            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); // réduction
    assert(buf1[5] == 'f');
    buf1.resize(1024); // agrandissement
    assert(buf1[5] == 'f');
}

Voir aussi