Why is there no reserving constructor for std::string?

Question

There are several constructors for std::string. I was looking for a way to avoid reallocation and I'm surprised that there is a fill constructor but no "reserve" constructor.

 std::string (size_t n, char c);

but no

 std::string (size_t n);

So do I have to call reserve() after it already allocated the default (16 bytes in my case), just to immediately reallocate it?

Is there a reason why there is no such constructor to reserve space directly when the object is created, instead of having to do it manually? Or am I missing something and there is some way to do this?

Using the fill constructor is a waste of time, because it will loop through the memory just to get overwritten, and also cause a wrong size, because s.length() reports N instead of 0.

Answer 1

This is all guesswork, but I'll try.

If you already know the size of the string that you need, you will most likely be copying data from somewhere else, e.g. from another string. In that case, you can call one of the constructors that accept char * or const std::string & to copy the data immediately.

Also, I can't see why using reserve right after constructing a string is a bad thing. While it is implementation-defined, I would assume that it would make sense for this code:

std::string str;
str.reserve(100);

to allocate memory for a total of 100 elements, not 116 (as in "allocate 16 first, then free them and allocate 100 more"), thus having no performance impact over the non-existent reserve constructor.

Also, if you just want an empty string without the default allocation at all, you can presumably use std::string str(0, ' '); which invalidates the "Using the fill constructor is a waste of time" point.

Answer 2

One of the use cases for reserve constructor might be using std::string with static/thread_local storage for cache variables.

void function(){
   thread_local std::string str; // no reserving constructor defined
}

For such scenarios, you may write a lambda function which constructs a std::string and also reserves desired amount of memory.

void function(){
    auto reserving_string_constr = [](std::size_t reserve_size){
        std::string str;
        str.reserve(reserve_size);
        return str;
    };
    thread_local std::string str(reserving_string_constr(128));
    /*...*/
}

Answer 3

you can basically ask the same question about every std::string method that is not embodied as a constructor.

for example, why don't we have a constructor which takes multiple strings and appends them one by one to the newly created string?

there can be many reasons why not to overload a constructor which reserve a memory. I think that in an Object Oriented setmind, the thought of a "reserved memory string" is a bit odd. the string represents a sequence of characters, not the memory behind it - which is implementation details, not the main feature.
when someone opens a new resturant, does he think to himself "when this resturant is finally open, on the very moment of opening I will reserve 100 sits for the alleged 100-people group that may or may not come!"

but your question implicitly states something very quitly: the lack of proper buffer objects in C++. you ask about reserve constructor because you want to use string as buffer, but zero-initializing them is very costly. reserveing the memory won't let you write beyond the string size.
so the solution to this problem is to use unique_ptr<char[]> which will not zero -initialize the characters, yet will give you the RAII style you are looking for.