CODEWITHSUNDEEP
c++stl
chbaker0
chbaker0

Reputation: 1788

Does std::string::clear reclaim the memory associated with a string?

For example, if loaded a text file into an std::string, did what I needed to do with it, then called clear() on it, would this release the memory that held the text? Or would I be better off just declaring it as a pointer, calling new when I need it, and deleting it when I'm done?

Upvotes: 18

Views: 16270

Answers (4)

Mario
Mario

Reputation: 322

I realized the OP is old but wanted to add some precision. I found this post when I was attempting to understand a behavior that seemed to contredict the answers provide here.

With gcc4.8.3, clear() might look like it's releasing memory in some scenario. 

std::string local("this is a test");
std::cout << "Before clear: " << local.capacity() << '\n';
local.clear();
std::cout << "After clear:  " << local.capacity() << '\n';

As expected I get

    Before clear: 14
    After clear: 14

Now lets add another string into the mix:

std::string local("this is a test");
std::string ref(local);  // created from a ref to local
std::cout << "Before clear: " << local.capacity() << '\n';
local.clear();
std::cout << "After clear:  " << local.capacity() << '\n';

This time I get:

    Before clear: 14
    After clear: 0

Looks like stdc++ has some optimisation to, whenever possible, share the memory holding the string content. Depending if a string is shared or not the behavior will differ. In the last example, when clear() is called, a new instance of the internal of std::string local is created and it will be empty(). The capacity will be set to 0. One might conclude from the ouput of capacity() that some memory was freed, but that is not the case.

This can be proven with the following code:

std::string local("this is a test");
std::string ref(local);  // created from a ref to local
std::cout << (int*)local.data() << ' ' << (int*)ref.data() << '\n';

Will give: 

    0x84668cc 0x84668cc

The two strings point to the same data, i was not execting that. Add a local.clear() or anything that modifies local or ref and the adresses will then differ, obviously.

Regards

Upvotes: 2

Vlad from Moscow
Vlad from Moscow

Reputation: 311018

The only valid method to release unused memory is to use member function shrink_to_fit(). Using swap has no any sense because the Standard does not say that unused memory will be released when this operation is used.

As an example

s.clear();
s.shrink_to_fit();

Upvotes: 9

Dietmar K&#252;hl
Dietmar K&#252;hl

Reputation: 153840

Calling std::string::clear() merely sets the size to zero. The capacity() won't change (nor will reserve()ing less memory than currently reserved change the capacity). If you want to reclaim the memory allocated for a string, you'll need to do something along the lines of

std::string(str).swap(str);

Copying the string str will generally only reserve a reasonable amount of memory and swapping it with str's representation will install the resulting representation into str. Obviously, if you want the string to be empty you could use

std::string().swap(str);

Upvotes: 25

Benjamin Lindley
Benjamin Lindley

Reputation: 103713

... would this release the memory that held the text?

No.

Or would I be better off just declaring it as a pointer ...

No, you'd be better off declaring the string in the scope in which it is needed, and letting its destructor be called. If you must release the memory in the scope which the string still exists, you can do this:

std::string().swap(the_string_to_clear);

Upvotes: 1

Related Questions