Cómo liberar correctamente una cadena estándar :: de la memoria

Question

¿Cuál es la mejor manera de eliminar una cadena estándar de la memoria asignada en el montón cuando termino de usarla? ¡Gracias!

Answer 1

std::string es solo una clase normal , por lo que se aplican las reglas habituales.

Si asigna std::string objetos en la pila, como globales, como miembros de la clase, ... no necesita hacer nada especial, cuando salen del alcance se llama a su destructor, y se encarga de liberar la memoria utilizada para la cadena de forma automática.

int MyUselessFunction() 
{ 
    std::string mystring="Just a string."; 
    // ... 
    return 42; 
    // no need to do anything, mystring goes out of scope and everything is cleaned up automatically 
} 

El único caso en el que usted tiene que hacer algo es cuando se asigna un std::string en el montón usando el operador new; en ese caso, como con cualquier objeto asignado con new, debe llamar al delete para liberarlo.

int MyUselessFunction() 
{ 
    // for some reason you feel the need to allocate that string on the heap 
    std::string * mystring= new std::string("Just a string."); 
    // ... 
    // deallocate it - notice that in the real world you'd use a smart pointer 
    delete mystring; 
    return 42; 
} 

Como implicado en el ejemplo, en general no tiene sentido asignar un std::string en el montón, y, cuando se necesita que, aún debe encapsular como puntero en un puntero inteligente para evitar aún a riesgo de pérdidas de memoria (en caso de excepciones, rutas de retorno múltiples, ...).

---

1. En realidad std::string se define como

   namespace std 
   { 
       typedef std::basic_string<char> string; 
   }; 
   

   por lo que es sinónimo de la creación de instancias de la clase basic_string plantilla para caracteres de tipo char (esto no cambia nada en la respuesta, pero en SO usted debe ser pedante incluso en preguntas de novatos).

Answer 2

Usa delete si está en el montón, y nada si está en la pila.

Answer 3

std::string foo("since it's on the stack, it will auto delete out of scope"); 

o:

std::string* foo = new std::string("allocated on the heap needs explicit destruction") 
delete foo; 

Answer 4

void foo() { 
    string* myString = new string("heap-allocated objects are deleted on 'delete myString;'"); 
    cout << *myString << endl; 
    delete myString; 
} 

o mejor aún, evitar punteros cuando sea posible y utilizar variables automáticas:

void foo() { 
    string myString("stack-allocated string is automatically deleted when myString goes out of scope"); 
    cout << myString << endl; 
} 

Answer 5

simplemente tratan std :: string como cualquier tipo básico

std::string *str = new std::string("whatever"); 
///code 
delete str;