std::string capacity remains same after deleting elements, so is it holding up some memory?

Question

The following piece of code:

string a = "abc";
cout << a.capacity();
a.erase(a.begin() + 1, a.end());
cout << a.capacity();

...outputs:

33

Even if I remove some elements from the string, the capacity remains the same. So my questions are:

1. Is some memory being held up because of capacity? What if I have not explicitly reserve()'d?

2. If I use reserve() and don't end up using the entire capacity, am I wasting memory?

3. Will this extra memory (which I am not using) be allocated to something else if required?

EDIT: Suppose i have

 string a= "something";
 a = "ab";

Now I know that a won't ever have more than two characters. So is it wise to call reserve(2) so that memory is not wasted?

Answer 1

I'll answer your questions first:

1. The memory belongs to the string, but isn't used entirely. If you don't reserve, you can't control the capacity. You just know it is sufficiently large.

2. Correct.

3. As said in 1): no. It belongs to the string. Nothing else can use this memory. The string itself could use it for additional characters though.

For further details I'd recommend the documentation of string::reserve.

One final remark: If you don't ever reserve, everything will work fine - it might be unnecessarily slow though. That is only ever the case if you were to frequently add few characters and the string has to re-alloc alot (much like a vector). Reserving is basically intended to bypass this situation.

---

On the addendum: Calling reserve can help to save memory. If you call reserve(n), this ensures the string has an internal capacity for at least n characters. Note that reserve is not required to set the capacity to exactly n nor to reduce the capacity at all for small n (cf. reserve documentation).

Back to your example: If you call reserve it can never do any harm. It's the best you can do in general. (In case you have C++11 features, I'd recommend shrink_to_fit).

I tested with (older) versions of gcc / clang in which cases the capacity of a got changed to exactly 2. Since I'm not 100% sure what the added question referes to, here is what I ran:

auto a = string{"something"};
a = "ab";
cout << a << " " << a.capacity() << endl;
a.reserve(2);
cout << a << " " << a.capacity() << endl;

Which produces:

ab 9
ab 2

Answer 2

1) Is some memory being held up because of capacity? What if i have not explicitly reserve()'d?

Even if you did not call reserve, the std::string object can still hold up some memory¹ for (even a default constructed) std::string. And this is true with std::string implementations that uses Short String Optimization

2)If i use std::reserve() and dont end up using the entire capcity then am i wasting memory?

It depends on what you mean by wasting memory; std::string dynamically resizes its buffer to accommodate changes in the size of the string. Well, in the case of Short String Optimized std::string implementations, there is nothing you can do about it. The memory is in the string object itself.

3)Will this extra memory which i am not using be allocated to something else, if required?

No. A std::string object manages the memory it allocated, and it may or may not give it up² wholly or partly, until its destroyed. See David Schwartz's comment

EDIT: Suppose i have

string a= "something";

Now i edit the string and know that a won't have more than two characters.So is it wise to call a.reserve(2) so that memory is not wasted?

If you modified a in a way that changes a.size(), such as calling resize method or assigning it to a new string of length 2, then the proceeding reserve call can² be beneficial.

Note that, calling reserve would not reduce the string's contents. std::string::reserve is not permitted to truncate the string. It is only permitted to work on unused memory. If you call std::string::reserve(new_capacity_intended) with new_capacity_intended less than the size() of the string, the best that could possibly happen is the same effect of std::string::shrink_to_fit.

To reduce the string's memory (if the implementation does a binding shrink_to_fit request) and shrink it to the first two characters:

string a= "something";
//resize it first
a.resize(2);  //or by some assignment such as a = "so";

//then
a.reserve(2); // or better still a.shrink_to_fit();

---

¹: by memory, I assume Virtual Memory

²: std::string::reserve or std::string::shrink_to_fit may or may not give up the string's unused memory.