¿Cómo sabe realloc cuánto copiar?

Question

¿cómo sabe realloc el tamaño de los datos originales?

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

lo tanto, si la aplicación es la siguiente:

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

Me di cuenta que no es la aplicación original, y realloc no siempre hace libre, pero cuando lo hace, cuánto lo hace ¿dupdo?

Edit: Gracias por las respuestas. ¿Pero cómo puedo implementar realloc en mi código con malloc/free/...?

Answer 1

Lo sabe porque malloc grabó esa información cuando la llamaste. Después de todo, el sistema tiene que realizar un seguimiento de los tamaños de los bloques asignados de todos modos para que no asigne una región de memoria particular dos veces.

Si quiere decir "cómo sabe la cantidad de arreglo que he escrito hasta ahora", no es necesario. También puede copiar cualquier basura no inicializada.

Answer 2

realloc (y malloc y libre) tienen acceso completo a la estructura de datos completa que compone el montón. En esa estructura de datos hay información sobre los tamaños de los bloques, lo que realloc necesita saber, y también lo hace el free.

Answer 3

Cuando tienes memoria, el bloque que obtienes suele ser un desplazamiento fijo en una estructura de datos más grande que también contiene información adicional, especialmente el tamaño del bloque. Puede verificar que esto sea cierto en algunos sistemas simplemente observando que cada dirección devuelta por malloc termina en 8 cuando se imprime en hexadecimal (por ejemplo, con la sustitución %p en printf). Por supuesto, realloc puede revertir este desplazamiento y volver a la estructura de administración de memoria, y así obtener el tamaño; a partir de ahí, ser capaz de saber cuánto para copiar (si fuera necesario) es trivial ...

Answer 4

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

Si ya está utilizando malloc & libre, ¿por qué no sólo tiene que utilizar realloc? de lo contrario, puede echar un vistazo a la fuente de CRT que se incluye con MSVC/gcc, etc. (o simplemente descargarla, en el caso de GCC), y ver cómo la implementan. Si el funcionamiento de un asignador de costumbre, entonces es un poco más la situación, por ejemplo: Yo uso un cubo binario con un sistema de tipo de losa, en cuyo caso realloc es simple:

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 5

¿Por qué no simplemente mirar hacia arriba ¿Cómo se implementa malloc/calloc/realloc/free en la biblioteca estándar C que está utilizando?

O, si no tiene acceso al código fuente, mire cómo se implementa en una de las bibliotecas estándar C de código abierto.