que - ¿Malloc dentro de una llamada a función parece liberarse a la vuelta?

que es la memoria dinamica en c

Question

Creo que lo tengo al caso más básico:

int main(int argc, char ** argv) {
int * arr;
foo(arr);
printf("car[3]=%d/n",arr[3]);
free (arr);
return 1;
}
void foo(int * arr) {
arr = (int*) malloc( sizeof(int)*25 );
arr[3] = 69;
}

El resultado es esto:

> ./a.out
car[3]=-1869558540
a.out(4100) malloc: *** error for object 0x8fe01037: Non-aligned pointer
being freed
*** set a breakpoint in malloc_error_break to debug
>

Si alguien puede arrojar luz sobre dónde está fallando mi comprensión, sería muy apreciado.

Answer 1

Como está pasando el puntero por valor, el puntero arr dentro de main no apunta a la memoria asignada. Esto significa dos cosas: tienes una fuga de memoria (NO, la memoria no se libera después de completar la función foo), y cuando accedes al puntero arr en main estás accediendo a un rango arbitrario de memoria, por No se imprimen 3 y, por lo tanto, free () se niega a trabajar. Tienes suerte de que no hayas tenido un error de segmentación al acceder a arr [3] dentro de main.

Answer 2

Ha asignado arr a foo, pero ese valor de los punteros se almacena en la pila de llamadas. Si quieres hacer esto, hazlo así:

void foo( int ** arr) {
*arr = (int *)malloc( sizeof(int) * 25 );
(*arr)[3] = 69;
}

Y en general, simplemente pase un puntero a foo (como foo (& arr))

Answer 3

No puede cambiar el valor de su argumento (arr) si no se pasa por referencia (&). En general, debería devolver el puntero, por lo que su método debería ser:

arr = foo ();

Es malo juju intentar reasignar argumentos; No recomiendo la (y) solución.

Answer 4

Pasa el puntero por valor, no por referencia, así que cualquier cosa que hagas con arr dentro de foo no hará la diferencia fuera de la función foo. Como escribió m_pGladiator, una forma es declarar una referencia a un puntero como este (solo posible en C ++ por cierto. C no conoce las referencias):

int main(int argc, char ** argv) {
int * arr;
foo(arr);
printf("car[3]=%d/n",arr[3]);
free (arr);
return 1;
}
void foo(int * &arr ) {
arr = (int*) malloc( sizeof(int)*25 );
arr[3] = 69;
}

Otra forma (mejor) es no pasar el puntero como argumento sino devolver un puntero:

int main(int argc, char ** argv) {
int * arr;
arr = foo();
printf("car[3]=%d/n",arr[3]);
free (arr);
return 1;
}
int * foo(void ) {
int * arr;
arr = (int*) malloc( sizeof(int)*25 );
arr[3] = 69;
return arr;
}

Y puede pasar un puntero a un puntero. Esa es la forma C de pasar por referencia. Complica un poco la sintaxis, pero bueno, así es como C es ...

int main(int argc, char ** argv) {
int * arr;
foo(&arr);
printf("car[3]=%d/n",arr[3]);
free (arr);
return 1;
}
void foo(int ** arr ) {
(*arr) = (int*) malloc( sizeof(int)*25 );
(*arr)[3] = 69;
}

Answer 5

foo recibe una copia local del puntero int, le asigna memoria y pierde esa memoria cuando se sale del alcance.

Una forma de arreglar esto para que foo devuelva el puntero:

int * foo() {
return (int*) malloc( sizeof(int)*25 );
}
int main() {
int* arr = foo();
}

Otra es pasar foo un puntero a un puntero

void foo(int ** arr) {
*arr = malloc(...);
}
int main() {
foo(&arr);
}

En C ++ es más simple modificar foo para aceptar una referencia a un puntero. El único cambio que necesita en C ++ es cambiar foo a

void foo(int * & arr)