libreria - ¿Cómo actualizar otros punteros cuando realloc mueve el bloque de memoria?

malloc y calloc

Question

La referencia realloc dice:

La función puede mover el bloque de memoria a una nueva ubicación, en cuyo caso se devuelve la nueva ubicación.

¿Significa que si hago esto?

void foo() {

        void* ptr = malloc( 1024 );

        unsigned char* cptr = ( unsigned char* )ptr+256;

        ptr = realloc( ptr, 4096 );
}

entonces cptr puede volverse inválido si realloc mueve el bloque?

En caso afirmativo, ¿el realloc señala de alguna manera, que moverá el bloque, de modo que pueda hacer algo para evitar que cptr deje de ser válido?

Answer 1

Esto viene un poco tarde, pero la solución a este problema (que nadie ha mencionado) es no usar los punteros en los bloques asignados que deberán asignarse. En su lugar, use desplazamientos de valores enteros desde el puntero base o (mejor) use un tipo de struct y elementos miembros para abordar ubicaciones específicas en el objeto asignado.

Answer 2

Sí, cptr dejará de ser válido cuando realloc mueva el bloque. Y no, no hay ninguna mención de señalizarle que diga que está moviendo el bloque de memoria. Por cierto, su código parece dudoso ... siga leyendo ... vea mi answer a otra pregunta y lea el código con mucho cuidado sobre cómo usa el realloc . El consenso general es si haces esto:

void *ptr = malloc(1024); /* later on in the code */ ptr = realloc(ptr, 4096); /* BAM! if realloc failed, your precious memory is stuffed! */

La forma de evitar eso es usar un puntero temporal y usarlo como se muestra:

void *ptr = malloc(1024); /* later on in the code */ void *tmp = realloc(ptr, 4096); if (tmp != null) ptr = tmp;

Edición: Gracias Seguro por señalar un gremlin que se introdujo cuando estaba escribiendo esto antes.

Answer 3

Sí, cptr será válido si realloc mueve el bloque.

No, no hay señal. Tendría que verificar el valor de retorno contra la ubicación ptr original.

Answer 4

Sí, el cptr se vuelve inválido si realloc mueve el bloque.

Answer 5

Sí.

Lo mejor que se puede hacer es comparar ptr antes y después de la reasignación, y ver si se ha movido. No debe asignar un puntero al valor de compensación, en su lugar debe almacenar la compensación y luego indexar el operador original con ella.

es decir

En lugar de void* newPtr = ptr + 10; *newPtr = something; void* newPtr = ptr + 10; *newPtr = something;

Use int new = 10; ptr[new] = something; int new = 10; ptr[new] = something;