C++ string uses maximum buffer allocated? - c++

Question

I declare a variable string s;
and do s = "abc"; now it has buffer of 3 characters.
After
s = "abcd" it has a buffer of 4 characters.
Now after the third statement
s = "ab" question is will it keep the buffer of 4 characters or will it reallocate a 2 character buffer?
If it will allocate 2 character buffer is there any way I can tell it to keep the allocated maximum buffer.
So does it keep the buffer of maximum size ever allocated ?
s = "ab"
s="abc"
s="a"
s="abcd"
s="b"
Now it should keep a buffer of size 4.
Is that possible?

Answer 1

The string will keep its buffer once it is allocated, and only reallocate if its needs an even larger buffer. It will also likely start with an initial buffer size larger than 3 or 4.
You can check the allocated size using the capacity() member function.
After James' comments below I still believe my answer is correct for the examples given in the question.
However, for a reference counted implementation a sequence like this
s = "some rather long string...";
std::string t = "b";
s = t;
would set s.capacity() to be equal to t.capacity() if the implementation decides to share the internal buffer between s and t.

Answer 2

s = "ab" question is will it keep buffer of 4 words or will it
reallocate 2 word buffer ?
It will not reallocate the buffer. I don't know if it's mentioned in the standard, but all the implementations I have ever seen issue a reallocation only if they need to increase the capacity. Never to decrease. Even if you have a string with 4 characters and call .resize(2) or .reserve(2) the capacity will not change. In order to force the string (or containers) to reallocate memory to fit the exact size, there's a simple swap trick for that
s.swap(string(s));
What happens here? You create a temporary from s which will have its capacity exactly equal to s.size() then swap it with your original string. The destructor of the temporary will free all the necessary resources.
Again, I am not claiming this is standard, but all the implementations I've seen have this behavior.

Answer 3

You can easily see the behavior of your implementation by calling
std::string::capacity at various times. In general, I'd be surprised
if any implementation ever had a buffer of three characters. (Not
words, but bytes, at least on most modern machines.) In practice,
implementations vary, and also vary depending on how the new length
comes about: with g++, for example, removing characters with
std::string::erase will not reduce the capacity of the string, but
assigning a new, smaller string will. VC++ doesn't reduce the capacity
in either case. (In general, VC++ and g++ have very different
strategies with regards to memory management in strings.)
EDIT:
Given the other responses (which don't even correspond to usual
practice): here's the small test program I used to verify my statements
above (although I really didn't need it for g++—I know the
internals of the implementation quite well):
#include <string>
#include <iostream>
#include <iomanip>
template<typename Traits>
void
test()
{
std::string s;
size_t lastSeen = -1;
std::cout << Traits::name() << ": Ascending:" << std::endl;
while ( s.size() < 150 ) {
if ( s.capacity() != lastSeen ) {
std::cout << " " << std::setw( 3 ) << s.size()
<< ": " << std::setw( 3 ) << s.capacity() << std::endl;
lastSeen = s.capacity();
}
Traits::grow( s );
}
std::cout << Traits::name() << ": Descending: " << std::endl;
while ( s.size() != 0 ) {
Traits::shrink( s );
if ( s.capacity() != lastSeen ) {
std::cout << " " << std::setw( 3 ) << s.size()
<< ": " << std::setw( 3 ) << s.capacity() << std::endl;
lastSeen = s.capacity();
}
}
std::cout << "Final: capacity = " << s.capacity() << std::endl;
}
struct Append
{
static void grow( std::string& s )
{
s += 'x';
}
static void shrink( std::string& s )
{
s.erase( s.end() - 1 );
}
static std::string name()
{
return "Append";
}
};
struct Assign
{
static void grow( std::string& s )
{
s = std::string( s.size() + 1, 'x' );
}
static void shrink( std::string& s )
{
s = std::string( s.size() - 1, 'x' );
}
static std::string name()
{
return "Assign";
}
};
int
main()
{
test<Append>();
test<Assign>();
return 0;
}
Try it. The results are quite instructive.