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)