In C, there is a nice construct to create a c-string with more allocated space:
char str[6] = "Hi"; // [H,i,0,0,0,0]
I thought I could do the same using (4) version of string constructor, but the reference says
The behavior is undefined if s does not point at an array of at least count elements of CharT.
So it is not safe to use
std::string("Hi", 6);
Is there any way to create such std::string without extra copies and reallocations?
Theory:
Legacy c-strings
Consider the following snippet:
int x[10];
void method() {
int y[10];
}
The first declaration, int x[10], uses static storage duration, defined by cppreference as: "The storage for the object is allocated when the program begins and deallocated when the program ends. Only one instance of the object exists. All objects declared at namespace scope (including global namespace) have this storage duration, plus those declared with static or extern."
In this case, the allocation happens when the program begins and freed when it ends. From cppreference.com:
static storage duration. The storage for the object is allocated when the program begins and deallocated when the program ends.
Informally, it is implementation-defined. But, since these strings never change they are stored in read-only memory segments (.BSS/.DATA) of the executable and are only referenced during run-time.
The second one, int y[10], uses automatic storage duration, defined by cppreference as: "The object is allocated at the beginning of the enclosing code block and deallocated at the end. All local objects have this storage duration, except those declared static, extern or thread_local."
In this case, there is a very simple allocation, a simple as moving the stack pointer in most cases.
std::string
A std::string on the other hand is a run-time creature, and it has to allocate some run-time memory:
char buffer[N] member)Practice
You could use reserve(). This method makes sure that the underlying buffer can hold at least N charT's.
Option 1: First reserve, then append
std::string str;
str.reserve(6);
str.append("Hi");
Option 2: First construct, then reserve
std::string str("Hi");
str.reserve(6);
std::string works. There's no way to avoid all of these step. Even if there was a c'tor that could do it "in one step". It would have to allocate a buffer, and copy the literal you give it.
char str[6]. It might do a simple stack allocation (for a local) or host it in the .BSS/.DATA segments (for a static/extern). But if you want to use a std::string there will be some kind of allocation (although strings have a default minimal block inside them that might be used to spare allocations for short strings).To ensure at most one runtime allocation, you could write:
std::string str("Hi\0\0\0", 6);
str.resize(2);
However, in practice many string implementations use the Small String Optimization, which makes no allocations if the string is "short" (up to size 16 is suggested on that thread). So actually you would not suffer a reallocation by starting the string off at size 2 and later increasing to 6.
std::string s = "Hi";will almost certainly allocate more that 2 characters so that you do not pay re-allocation penalty if you only increase the string's size by as little as6characters.std::string s = "Hi"; scanf("%4s", &s[2]);- can you be 100% sure that this won't cause segmentation fault?size()of the string without invoking undefined behavior. So even if you could do what you want to do you still can'tscanf("%4s", &s[2]);. I was just pointing out that as far as reallocations go, the string probably already makes fairly sensible decisions.