Is it bad to depend on index 0 of an empty std::string?

Question

std::string my_string = ""; char test = my_string[0]; 

I've noticed that this doesn't crash, and every time I've tested it, test is 0.

Can I depend on it always being 0? or is it arbitrary?

Is this bad programming?

Edit: From some comments, I gather that there is some misunderstanding about the usefulness of this.

The purpose of this is NOT to check to see if the string is empty. It is to not need to check whether the string is empty.

The situation is that there is a string that may or may not be empty. I only care about the first character of this string (if it is not empty).

It seems to me, it would be less efficient to check to see if the string is empty, and then, if it isn't empty, look at the first character.

if (! my_string.empty())     test = my_string[0]; else     test = 0; 

Instead, I can just look at the first character without needing to check to see if the string is empty.

test = my_string[0]; 

Answer 1

C++14

No; you can depend on it.

In 21.4.5.2 (or [string.access]) we can find:

Returns: *(begin() + pos) if pos < size(). Otherwise, returns a reference to an object of type charT with value charT(), where modifying the object leads to undefined behavior.

In other words, when pos == size() (which is true when both are 0), the operator will return a reference to a default-constructed character type which you are forbidden to modify.

It is not special-cased for the empty (or 0-sized) strings and works the same for every length.

---

C++03

_{And most certainly C++98 as well.}

It depends.

Here's 21.3.4.1 from the official ISO/IEC 14882:

Returns: If pos < size(), returns data()[pos]. Otherwise, if pos == size(), the const version returns charT(). Otherwise, the behavior is undefined.