Preservacion del contenido de la memoria en contra de tiempo de vida de variable

[NextByte]

Buenas a todos, teniendo en cuenta el siguiente programa:

Código (cpp) [Seleccionar] Expandir


#include <iostream>

using namespace std;
int *ptr;

void h(){
     int a = 333;
     ptr = &a;
     cout << "Direccion de memoria" << ptr << endl;
}


int main(){
 
     h();
     cout << *ptr << endl;
}


A través del programa anterior tengo un puntero global, este puntero lo hago que apunte a una variable y simplemente despues verifico que realmente si apunte a ella. Mi pregunta es... la variable 'a' que esta declarada en la función 'h' a la cual hago que apunte ptr dentro de la función tiene un tiempo de vida que se ve limitada por las llaves de la función, cuando yo regreso al main el tiempo de vida de la variable 'a' ha terminado sin embargo el espacio de memoria donde estaba contenido y que ahora es apuntado por el puntero ¿sigue estando reservado?, es decir, ¿ese espacio de memoria sigue siendo considerado como ocupado por una variable? o fue liberado al mismo tiempo que termino el tiempo de vida de la variable 'a'. Tengo la incertidumbre de si ese pedazo de memoria regreso al conjunto de la memoria disponible pero sin embargo sigue teniendo los valores que anteriormente fueron utilizados para representar a la variable 'a' y que pueda ser posible que por ahora el apuntador me siga mostrando ese valor pero sin embargo conforme vaya avanzando un programa y se reserve memoria etc... Ese segmento de memoria pueda llegar a ser sobrescrito por un nuevo valor de una variable .

[srWhiteSkull]

No, no se destruye y tampoco puedes reservar en ese espacio que se encuentra en la pila del programa. Las variables además no son punteros son una referencia a ese espacio que se reemplazan al compilar. Cuando compilas A ya no existe, solo en el codigo fuente.

Por otro lado cuando un espacio es liberado, trabajando con punteros, el espacio sigue manteniendo el contenido que tenía, no se rellena con ceros.

[NextByte]

No, no se destruye y tampoco puedes reservar en ese espacio que se encuentra en la pila del programa. Las variables además no son punteros son una referencia a ese espacio que se reemplazan al compilar. Cuando compilas A ya no existe, solo en el codigo fuente.

Por otro lado cuando un espacio es liberado, trabajando con punteros, el espacio sigue manteniendo el contenido que tenía, no se rellena con ceros.

Cuando dices que "No, no se destruye y tampoco puedes reservar en ese espacio que se encuentra en la pila del programa. " haces referencia a que una vez que se termino el tiempo de vida de la variable aún se sigue preservando el espacio en la pila del programa debido a que el puntero hace referencia a esa zona de memoria ? . Comprendo que no se rellene con 0 una vez que se llega a liberar la memoria pero mi duda es como determina que segmentos de memoria deben regresarse al conjunto de memoria disponible . En el ejemplo anterior yo  pensaria  que tal vez en tiempo de compilacion la memoria a la que hacia referencia la variable 'a' va ser liberada o pasada al conjunto de memoria disponible cuando se termina el bloque de codigo donde fue declarada sin embargo en el caso de que un puntero global haya hecho referencia ese segmento de memoria antes... el compilador detecta que aunque el tiempo de vida de la referencia("variable a") ha terminado se tiene un puntero que apunta a ese segmento de memoria y por lo tanto ese segmento de memoria permanece en la pila del programa.

[srWhiteSkull]

Mira es fácil de entender, la pila del programa es un espacio estático, lo reserva el compilador, no se reserva en tiempo de ejecución. Mientras que cuando reservas memoria dinámica, con new, malloc o lo que sea, le pides al sistema dinamicamente que te reserve un espacio el cual es neceserio liberar, y la pila se libera al finalizar el programa.

[Loretz]

El espacio de memoria donde estaba contenido y que ahora es apuntado por el puntero ¿sigue estando reservado?

No, al volver de h() ya no está reservado.

es decir, ¿ese espacio de memoria sigue siendo considerado como ocupado por una variable?

No, ya no.

o fue liberado al mismo tiempo que termino el tiempo de vida de la variable 'a'.

Sí, así es.

Tengo la incertidumbre de si ese pedazo de memoria regreso al conjunto de la memoria disponible...

Sí, vuelve a estar disponible (es una porción de memoria en la stack, automática).

... pero sin embargo sigue teniendo los valores que anteriormente fueron utilizados para representar a la variable 'a' ...

Puede tenerlos o no, después de volver de h() su valor es "indefinido" (quizá sí, quizá no), algunos compiladores le asignarán un cero, otros lo dejarán como está, en otros contendrá cualquier cosa al azar; para el lenguaje su valor es "indefinido".

... y que pueda ser posible que por ahora el apuntador me siga mostrando ese valor pero sin embargo conforme vaya avanzando un programa y se reserve memoria etc...

Puede ser posible, pero depende del compilador y de la suerte que tengas ese día. Es lo que el estándar C++ califica como "Undefined Behavior" (comportamiento indefinido, si pretender leerlo o desreferenciarlo puede pasar cualquier cosa, normalmente mala).

Ese segmento de memoria pueda llegar a ser sobrescrito por un nuevo valor de una variable .

Sí, es memoria disponible para el programa, ¿por qué no?

[NextByte]

Mira es fácil de entender, la pila del programa es un espacio estático, lo reserva el compilador, no se reserva en tiempo de ejecución. Mientras que cuando reservas memoria dinámica, con new, malloc o lo que sea, le pides al sistema dinamicamente que te reserve un espacio el cual es neceserio destruir.

Ohh... Ahora entiendo... Entonces cuando en los cursos basicos hablan sobre el tiempo de vida de una variable solo hacen referencia a la zona o area donde vas a poder acceder a una direccion de memoria a la cual hace referencia esa variable pero sin embargo cuando sale de ese tiempo de vida no es que exista una liberacion de memoria sino que simplemente ya no se puede acceder con el nombre de esa variable. Supongo entonces que el hecho de que se crearan los tiempos de vida fue por el hecho de intentar crear programas mas faciles de mantener y evitar todo global por que realmente no es que se este haciendo alguna optimizacion de memoria en el sentido de que se esta liberando memoria con las variables que sobrepasaron su tiempo de vida.

[NextByte]

No, al volver de h() ya no está reservado.
No, ya no.
Sí, así es.
Sí, vuelve a estar disponible (es una porción de memoria en la stack, automática).
Puede tenerlos o no, después de volver de h() su valor es "indefinido" (quizá sí, quizá no), algunos compiladores le asignarán un cero, otros lo dejarán como está, en otros contendrá cualquier cosa al azar; para el lenguaje su valor es "indefinido".
Puede ser posible, pero depende del compilador y de la suerte que tengas ese día. Es lo que el estándar C++ califica como "Undefined Behavior" (comportamiento indefinido, si pretender leerlo o desreferenciarlo puede pasar cualquier cosa, normalmente mala).
Sí, es memoria disponible para el programa, ¿por qué no?

Desde tu punto de vista entonces a diferencia de "srWhiteSkull" hablas de que la pila de variables que el menciona como estatica tu haces referencia de que puede llegar a comportarse de manera dinamica de manera que cuando entra-sale de la funcion todos lo segmentos de memoria que componen a las variables declaradas en ella son regresadas a memoria disponible incluso cuando existe un puntero que tiene un ambito global y que hace referencia a un segmento de memoria que era parte de una variable de la cual su ambito o su tiempo de vida ya ha terminado. ¿Algo asi ?, o ¿estoy mal interpretando alguna de las dos respuestas?

[srWhiteSkull]

No es una pila de variables... Look at this
[youtube=640,360]https://www.youtube.com/watch?v=_8-ht2AKyH4[/youtube]

[MAFUS]

Imagínate que trabajas en un edificio de oficinas y tú y tu equipo trabajáis en una.
Vais a emprender un proyecto nuevo y necesitas más espacio así que se lo dices a tu jefe y os cede otro espacio, te da una llave para que puedas acceder a ella. Esa llave es tu puntero y la oficina nueva tu variable.
Trabajas con tu oficina, pones y quitas mobiliario cómo quieras. Trabajas con tu variable.
Tu proyecto termina y el jefe la libera de tu propiedad pero en vez de devolver la llave te la quedas. Eso es: la función termina pero tu puntero sigue apuntando allí.
Teniendo la llave puedes entrar y ver lo que hay o poner cosas ¿por qué no? tienes la llave. Si la oficina no ha sido asignada a nadie mas no haces daño a nadie, tan solo puede ocurrir que el jefe se enfade, pero si la oficina ha sido asignada a otro grupo ya los vas a molestar, incluso puede que mandes al traste el trabajo que están haciendo.

[NextByte]

Gracias a todos por su tiempo y comentarios, solo quisiera reafirmar si lo que pienso es correcto.
En el programa del inicio entonces tendria la siguiente situación.......
1. En la memoria 'stack' yo tendria inicialmente a la funcion main con todas su variables y en la memoria global tendria al puntero
2. Entra a la funcion 'h()' por lo cual en la memoria 'stack' se ve almacenada la informacion de la funcion y con ella la variable 'a'.( El proyecto dentro de una empresa empieza y me asigna una oficina ).
3. El puntero apunta a la dirección de memoria que tiene la variable 'a' . ( Tengo una llave que me ayuda a abrir la oficina ).
4. Termina la función 'h()' y por lo tanto se regresa a la funcion main con lo cual para el programa tanto las variables 'a' como el segmento de memoria que ella ocupaba ya no esta ocupado aun que yo tenga un puntero global apuntado anteriormente a ella ( El proyecto finaliza pero se me permite seguir conservando la llave ).
5. Finalmente se puede dar que con el puntero final yo pueda seguir accediendo a ese segmento de memoria y succeda algo de lo siguiente:
      -El segmento de memoria sigue conservando el valor que yo asigne a la variable 'a'.
      -El segmento de memoria contenga valores que el compilador asigno cuando se salio de la funcion para representar que esta vacio.
      -Que yo pueda seguir viendo el mismo valor de 'a' por gran parte del programa pero que pueda que tenga la mala suerte que ese segmento de memoria llegue a ser ocupado por el valor de una nueva variable y que al yo seguir haciendo referencia con el puntero global  no me puedo fiar en que ese segmento de memoria siga conteniendo el valor de 'a' que se le asigno inicialmente.


Finalmente entonces para asegurar que el puntero global pueda seguir conservando el valor 'a' sin problemas deberia hacer uso de una reservacion de memoria de manera dinamica con ayuda de new o malloc y asignarle el valor de la variable 'a'.