How to properly free a std::string from memory

Question

What's the best way to delete an std::string from memory allocated on the heap when I'm done using it? Thanks!

Answer 1

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

or:

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

Answer 2

Use delete if it's on the heap, and nothing at all if it's on the stack.

Answer 3

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

or better yet, avoid pointers when possible and use automatic variables:

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

Answer 4

just treat std::string as any basic type.

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

Answer 5

Maybe your dealing with really freeing the internal string buffer?

For performance reason, most implementation keep the internal buffer allocated, even is the string is "emptied". Additionally: small strings (smaller than sizeof(ptr)) are directly stored in the area that hold pointers. Theses bytes can never be reclaimed during the life of the string.

To free the internals: the classical trick is to use swap within a scope. This force buffer to be really freed (Works also with vector/map/ostream/stringstream etc ...):

string s;                                               // size==0 and capacity==15 as the default proxy of the container (help perf on small string)
s = "Looooooooooooooooooooooooooooooong String";        // size==41 and capacity==47 bytes allocated
s.clear();                                              // size==0  BUT capacity==47 bytes STILL allocated!!
        
s = "Looooooooooooooooooooooooooooooong String";        // size==41 and capacity reuse 47 bytes still allocated. 
s.resize(0);                                            // size==0  BUT capacity==47 bytes STILL allocated!!
// swap with scope to force freeing string internals
{ 
    string o;
    o.swap(s);
}                                                       // size==0 AND capacity==15 (back to smallest footprint possible)
s = "12345";                                            // size==5 AND capacity==15 (the string is IN the container, no new alloc)

Answer 6

You can treat std::string like any other class. Use new for allocation, and delete once you're done with it. With C++11, I do not recommend usage of new and delete in most cases. If you need to allocate the string on heap, use std::shared_ptr to wrap it:

std::shared_ptr<std::string> my_string = std::make_shared<std::string>(std::string("My string"));

As soon as all the copies of my_string go out of scope, the associated memory is going to be deleted automatically.