¿Cuándo se eliminan las variables de la memoria en C++?

Question

He estado usando C++ por un momento ahora. Estoy nunca seguro de cómo funciona la gestión de memoria, así que aquí va:

estoy en primer lugar seguro de cómo la memoria está sin asignar en una función, por ejemplo:

int addTwo(int num) 
{ 
    int temp = 2; 
    num += temp; 
    return num; 
} 

lo tanto, en este ejemplo, ¿La temperatura se eliminaría de la memoria una vez que la función termine? Si no, ¿cómo se hace esto? En C# una variable se elimina una vez que se agote su alcance. ¿Hay algún otro caso que deba saber?

Gracias

Answer 1

La variable local temp se "empujan" en una pila en el comienzo de la función y "estallar" de la pila cuando se cierra la función.

Aquí está un desmontaje de una versión no optimizada:

int addTwo(int num) 
{ 
00411380 push  ebp 
00411381 mov   ebp,esp    //Store current stack pointer 
00411383 sub   esp,0CCh   //Reserve space on stack for locals etc 
00411389 push  ebx 
0041138A push  esi 
0041138B push  edi 
0041138C lea   edi,[ebp-0CCh] 
00411392 mov   ecx,33h 
00411397 mov   eax,0CCCCCCCCh 
0041139C rep stos dword ptr es:[edi] 
    int temp = 2; 
0041139E mov   dword ptr [temp],2 
    num += temp; 
004113A5 mov   eax,dword ptr [num] 
004113A8 add   eax,dword ptr [temp] 
004113AB mov   dword ptr [num],eax 
    return num; 
004113AE mov   eax,dword ptr [num] 
} 
004113B1 pop   edi 
004113B2 pop   esi 
004113B3 pop   ebx 
004113B4 mov   esp,ebp     //Restore stack pointer 
004113B6 pop   ebp 
004113B7 ret   

Los términos "empujados" y "metimos" no son más que significaba como una analogía. Como se puede ver en el resultado del ensamblaje, el compilador reserva toda la memoria para las variables locales, etc. de una vez al restar un valor adecuado del puntero de la pila.

Answer 2

La temperatura variable se asigna a la pila. Eso significa que está desasignado cuando la función regresa.

Ver ej .:

• http://msdn.microsoft.com/en-us/library/ew5tede7%28VS.80%29.aspx
• http://en.wikipedia.org/wiki/Stack_%28data_structure%29

Answer 3

Aquí, temp se asigna en la pila, y la memoria que se utiliza se libera automáticamente cuando se cierra la función. Sin embargo, usted podría asignarlo en el montón de la siguiente manera:

int *temp = new int(2); 

Para liberarla, que tiene que hacer

delete temp; 

Si asigna la variable en la pila, esto es lo que normalmente sucede:

Cuando llame a su función, incrementará esta cosa llamada 'puntero de la pila', un número que indica qué direcciones de la memoria deben 'protegerse' para ser utilizadas por sus variables locales. Cuando la función retorna, disminuirá el puntero de la pila a su valor original. En realidad, no se hace nada con las variables que ha asignado en esa función, excepto que la memoria en la que residen ya no está "protegida"; cualquier otra cosa puede (y finalmente lo hará) sobrescribirlas. Entonces se supone que no debes tener acceso a ellos por más tiempo.

Si necesita que la memoria asignada persista después de que haya salido de la función, utilice el montón.

Answer 4

temp está asignado en la pila. Entonces cuando la función regresa, se va.

Las reglas de alcance de C++ son similares a C#.

Answer 5

No se elimina de la memoria una vez que la función finaliza.

Permanece en la memoria, en el marco de la pila de Two, hasta que algún otro proceso (o el mismo) re use esa parte de la memoria.

Hasta ese momento, acceder a la temperatura es un comportamiento indefinido.

Answer 6

En este caso, tanto num como temp son locales para esta función. Cuando se llama a la función, el número pasado a num se copia de la persona que llama a una variable en la pila. La temperatura se crea en la pila. Cuando regresa, el valor de num se copia nuevamente a la persona que llama, y ​​las variables temporales y numéricas utilizadas en la función se descartan.

Answer 7

En C, C++ variables locales tienen automática de clase de almacenamiento y se almacenan en Pila.

Cuando la función retorna, la pila se desenrolla y los locales ya no son accesibles, pero aún persisten en la memoria y esa es la razón por la que al definir una variable en la función puede contener valor basura.

Es solo la manipulación del puntero de la pila en la pila y en la memoria para el local se elimina en realidad.

Answer 8

En C++ no es una regla muy simple de oro:

Toda la memoria se libera automáticamente cuando se ejecuta fuera de alcance a menos que se le ha asignado manualmente.

asignaciones manuales:

• Cualquier objeto asignado por la nueva() deben estar sin asignar por una coincidencia de borrar().
• Cualquier memoria asignada por malloc() DEBE ser desasignada por un coincidente libre().

Un patrón de diseño muy útil en C++ se llama RAII (Resource Acquisition Is Initialization) que se une asignaciones dinámicas a un objeto de ámbito que libera la asignación en su destructor.

En el código RAII ya no tiene que preocuparse por llamar a delete() o free() porque se llaman automáticamente cada vez que el "objeto de anclaje" se queda fuera del alcance.

Answer 9

Consulte mi respuesta a esta pregunta. Puede aclarar un montón de cosas para oyu.

How does automatic memory allocation actually work in C++?

No estoy publicación de un enlace por diversión. Mi respuesta es una mirada profunda (en un nivel muy introductorio) de cómo funciona la administración de memoria.

Answer 10

En C++, cualquier objeto que declare en cualquier ámbito se eliminará cuando se cierre el ámbito. En el ejemplo siguiente, se llama al constructor predeterminado cuando se declara el objeto y se invoca al destructor al salir, es decir, ~ MyClass.

void foo() { 
    MyClass object; 
    object.makeWonders(); 
} 

Si se declara un puntero en una función, entonces el puntero en sí (los 4 bytes para sistemas de 32 bits) obtiene reclamados cuando las salidas con ámbito, pero la memoria es posible que haya asignado el uso de operador nuevo o malloc perdurará - esto a menudo se conoce como pérdida de memoria.

void foo() { 
    MyClass* object = new MyClass; 
    object->makeWonders(); 
    // leaking sizeof(MyClass) bytes. 
} 

Si realmente debe asignar un objeto a través de nuevo que necesita ser eliminada cuando sale del alcance, entonces debería usar boost :: scoped_ptr así:

void foo() { 
    boost::scoped_ptr<MyClass> object(new MyClass); 
    object->makeWonders(); 
    // memory allocated by new gets automatically deleted here. 
} 

Answer 11

Normalmente Gestión de memoria se utiliza en el contexto de la memoria dinámica que se crea por

new 
malloc 

En el código C++ normales se comporta como cualquier otro idioma. Si crea una variable o la devuelve, se copia y se puede acceder desde el lado de destino.

int a = addTwo(3); 

obtiene una copia del valor devuelto. Si el valor devuelto es un operador de copia de clase llamado. Así que mientras no trabajes con new y malloc no tienes que preocuparte tanto por la administración de la memoria.

Una observación adicional que es importante

void func(std::string abc) 
{ 
    // method gets a copy of abc 
} 

void func(std::string& abc) 
{ 
    // method gets the original string object which can be modified without having to return it 
} 

void func(const std::string& abc) 
{ 
    // method gets the original string object abc but is not able to modify it  
} 

La diferencia de las tres líneas es muy importante debido a que su programa puede ahorrar mucho tiempo la creación de copias de los parámetros de entrada que normalmente no desea crear.

p. Ej.

bool CmpString(std::string a, std::string b) 
{ 
    return a.compare(b); 
} 

es muy caro porque las cuerdas a y b siempre se copian. Utilice

bool CmpString(const std::string& a, const std::string& b) 

en su lugar.

Esto es importante porque no se utilizan objetos refconados por defecto.