C / Glib Memory Management {sin referencia colgante > ¿Por qué?

Question

Tengo un programa que llama a una función con argumentos indefinidos, como este:

#include <stdargs.h>

... /* code */
int main () { 

  GArray *garray = g_array_new (FALSE, FALSE, sizeof (char *));
  /* the code above initialize the GArray, and say that the garray expect a pointer to char. */

  function_name (garray, "arg2", "arg3" /* and so on ... */);

  ... /* code */
}

tenga en cuenta que, los argumentos entre " " son cadenas, entonces, en el function_name:

static void function_name (GArray *garray, ...) {
  ... /* code */
  char *data;

  data = va_arg (garray, gchar *);
  g_array_append_val (garray, data);

  ... /* code */
}

& nbsp; & nbsp; & nbsp; Entonces, si los datos apuntan a un argumento en va_list, cuando la función retorna, teóricamente los datos apuntan, se invalidan y también en garray.
 (provocando una referencia colgante, porque el puntero de datos apunta a una dirección de memoria no reservada más).

& nbsp; & nbsp; & nbsp; pero no parece suceder, el programa funciona bien. ¿por qué? y, en C, los argumentos pasados ??a las funciones se almacenan en la pila, entonces, ¿los datos apuntan a la vida en la pila de hecho memoria?

muchas gracias.

Answer 1

Cuando introduce una constante de cadena en un programa en C, se crea un objeto sin nombre, no modificable, con una duración de almacenamiento estático. " Duración del almacenamiento estático " significa que vive por la vida del programa.

Entonces, cuando tienes esto en tu código:

function_name (garray, "arg2", "arg3" /* and so on ... */);

Las cadenas '' arg2 '' y '' arg3 '' son constantes de cadena: existen en algún lugar de la memoria del programa, durante la vida útil del programa . A menudo, estos se almacenan en un segmento de texto, de la misma manera que el código del programa en sí.

Lo que realmente se pasa a function_name (), presumiblemente en la pila, son punteros a esas constantes de cadena. Y eso es lo que su GArray termina almacenando: punteros a esas constantes de cadena.

(Tenga en cuenta que una cadena utilizada como un inicializador de matriz es no una constante de cadena).

Answer 2

Una de las tres cosas es cierta:

Cualquiera de los dos: 1) g_array_append_val está haciendo una copia de la cadena.

O: 2) tan pronto como se sobrescriba la pila nuevamente, las cosas se romperán.

void burn_stack(int size)
{
   char data[8]={0,0,0,0,0,0,0,0};
   size-=8;
   if (size>0) burn_stack(size);
}

Intente llamar a burn_stack (256); después de function_name, y vea si las cosas continúan funcionando.

O: 3) Está utilizando const char '' string '' s, que se almacenan en la sección de cadena del ejecutable, y no en el montón ni en la pila, por lo tanto, persistirán indefinidamente.