Come fa sapere quanto realloc copiare?

Question

In che modo realloc conoscere la dimensione dei dati originali?

 void *realloc(void *ptr, size_t size);

Quindi, se l'implementazione è in questo modo:

 temp = malloc(size);
 memcpy(.. // How much to copy?
 free(ptr);
 return temp;

Mi rendo conto che questo non è l'implementazione originale, e realloc non sempre lo fanno gratis, ma quando lo fa, quanto fa copia?

Modifica: Grazie per le risposte. Ma come posso quindi implementare realloc nel mio codice con malloc / libera /..?

Answer 1

Si sa perché malloc registrato che le informazioni quando si chiama esso. Dopo tutto, il sistema deve tenere traccia delle dimensioni dei blocchi allocati comunque in modo che esso non assegna una particolare regione di memoria due volte.

Se vuoi dire, "come fa a sapere quanto di matrice che ho scritto nella misura", che non ha bisogno di. Si può semplicemente copiare qualsiasi spazzatura Non inizializzato pure.

Answer 2

But how can I then implement realloc in my code with malloc/free/..?

Se si sta già utilizzando malloc & free, perché non basta usare realloc? altrimenti si può solo dare un'occhiata alla fonte CRT fornito con MSVC / gcc ecc (o semplicemente scaricarlo, nel caso di GCC), e vedere come implementarla. Se la vostra esecuzione di un allocatore personalizzato, quindi è un po 'di più della situazione, per esempio: io uso un bidone binario con un sistema di tipo lastra, nel qual caso realloc è semplice:

void* Reallocate(Manager* pManager, void* pBlock, size_t nSize, const char* szFile, const DWORD dwLine)
{
    #if ( MMANAGER_NULL_TO_DEFAULT )
        if(pManager == NULL)
            pManager = MMANAGER_DEFUALT_MANAGER;
    #endif

    if(pBlock == NULL)
        return Allocate(pManager,nSize,szFile,dwLine);
    else if(nSize == 0)
    {
        Free(pManager,pBlock,szFile,dwLine);
        return NULL;
    }

    BlockHeader* pHeader = GetHeader(pBlock);
    size_t nPrevSize = pHeader->pPoolBlock->nSize;
    if(nPrevSize < nSize)
    {
        void* pNewBlock = Allocate(pManager,nSize,szFile,dwLine);
        memcpy(pNewBlock,pBlock,nPrevSize);
        PoolBlock* pPoolBlock = pHeader->pPoolBlock;
        if(pPoolBlock == NULL)
            free(pHeader);
        else
            FreeBlock(pPoolBlock,pHeader);

        return pNewBlock;
    }

    return pBlock;
}

Answer 3

realloc (e malloc e gratuito) hanno pieno accesso a tutta la datastructure che compone il mucchio. In quel datastructure sono informazioni circa le dimensioni dei blocchi, che le esigenze realloc sapere, e così fa liberi.

Answer 4

Quando si malloc po 'di memoria, il blocco che si ottiene è di solito un offset fisso in una struttura di dati più grande che contiene anche informazioni supplementari, in particolare la dimensione del blocco. È possibile verificare che questo è vero in alcuni sistemi semplicemente osservando che ogni indirizzo restituito da estremità malloc in 8 quando stampati in esadecimale (ad esempio, con la sostituzione di %p printf). Naturalmente, realloc può invertire questo offset e tornare alla struttura di gestione della memoria, e così ottenere la dimensione; da lì, essendo in grado di sapere quanto a copiare (quando necessario) è banale ...

Answer 5

Perché non basta guardare in alto come malloc / calloc / realloc / libero è implementato nella libreria standard C si sta utilizzando?

In alternativa, se non si ha accesso al codice sorgente, sguardo a come è implementato in una delle librerie C standard di open-source.