Is it safe to write to a std::strings buffer directly?

Question

If I have the following code:

std::string hello = "hello world"; 
char* internalBuffer = &hello[0];

Is it then safe to write to internalBuffer up to hello.length()? Or is this UB/implemention defined? Obviously I can write tests and see that this works, but it doesn't answer my question.

Since `str[i] = 'c'` is well-defined, I would expect your example to be well-defined as well. I'm curious what the answer might be. — Paul Manta, Jan 14 '14 at 10:16
Possibly duplicate of http://stackoverflow.com/questions/1986966/does-s0-point-to-contiguous-characters-in-a-stdstring — axe, Jan 14 '14 at 10:36
@axe Not a duplicate, as this behavior was changed with C++11. — ComicSansMS, Jan 14 '14 at 10:42

score 2 · Accepted Answer · answered Jan 14 '14 at 10:59

Yes, it's safe. No, it's not explicitly allowed by the standard.
According to my copy of the standard draft from like half a year ago, they do assure that data() points at a contiguous array, and that that array be the same as what you receive from operator[]:

21.4.7.1 basic_string accessors [string.accessors]
const charT* c_str() const noexcept;
const charT* data() const noexcept;
Returns: A pointer p such that p + i == &operator[](i) for each i in [0,size()].

From this one can conclude that operator[] returns a reference to some place within that contiguous array. They also allow the returned reference from (non-const) operator[] be modified.
Having a non-const reference to one member of an array I dare to say that we can modify the entire array.

ComicSansMS · Answer 2 · 2014-01-14T10:18:38.940

The relevant section in the standard is §21.4.5:

const_reference operator[](size_type pos) const noexcept;

reference operator[](size_type pos) noexcept;

[...]

Returns: *(begin() + pos) if pos < size(), otherwise a reference to an object of type T with value charT(); the referenced value shall not be modified.

If I understand this correctly, it means that as long as the index given to operator[] is smaller than the string's size, one is allowed to modify the value. If however, the index is equal to size and thus we obtain the \0 terminating the string, we must not write to this value.

Cppreference uses a slightly different wording here:

If pos == size(), a reference to the character with value CharT() (the null character) is returned. For the first (non-const) version,the behavior is undefined if this character is modified.

I read this such that 'this character' here only refers to the default constructed CharT, and not to the reference returned in the other case. But I admit that the wording is a bit confusing here.

Such a phrase is normally to apply to the whole of "`*(begin() + pos)` if `pos < size()`, otherwise a reference to an object of type `T` with value `charT()`", but that would not make any sense here. — , Jan 14 '14 at 11:01
...which is why the text has been changed in later drafts ([according to this answer to a different question](http://stackoverflow.com/a/18078800/743382)). — , Jan 14 '14 at 11:03

axe · Answer 3 · 2014-01-14T10:37:43.177

0

In practice it is safe, theoretically - no.

C++ standard doesn't force to implement string as a sequential character array like it does for the vector. I'm not aware of any implementation of string where it is not safe, but theoretically there is no guarantee.

http://herbsutter.com/2008/04/07/cringe-not-vectors-are-guaranteed-to-be-contiguous/

edited Jan 14 '14 at 10:37

answered Jan 14 '14 at 10:32

axe

2,331
4
31
53

Oh, maybe it's changed in the latest standard. Need to check. – axe Jan 14 '14 at 10:42
AFAIK yes it changes, it was decided from the fact that it was implemented like that anyway in the different libraries. – Jaffa Jan 14 '14 at 10:50

Is it safe to write to a std::strings buffer directly?

3 Answers3