Btukfyl

In case of std::string, if we access an element where (element position) > (size of string) the standard says that it returns a reference to an object of type charT with value charT().

const_reference operator(size_type pos) const;

reference       operator(size_type pos);

Expects: pos <= size().

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

http://eel.is/c++draft/strings#string.access-1

Unfortunately I couldn't reason about this, it would have been better if it has been Undefined Behavior.

Can somebody explain the rationale behind this?

You have to consider the full specs.

First of all:

Expects: pos <= size().

If you dont follow the precondition you have undefined behaviour anyhow. Now...

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

The only (valid) case that "otherwise" refers to is when pos == size(). And that is probably to emulate c string behaviour that have a some_string[size] element that can be accessed. Note that charT() is typically just ''.

PS: One might think that to implement the specification, operator would have to check if pos == size. However, if the underlying character array has a charT() at the end of the string, then you get the described behaviour basically for free. Hence, what seems a little different from "usual" access into an array is actually just that.

Statement 1 is the precondition for statement 2:

1. Expects: pos <= size().



2. 
   

   Returns: *(begin() + pos) if pos < size().

   
   
   

   Otherwise (so here the only viable possibility is pos == size()), returns a reference to an object of type charT with value charT() (i.e. ''), where modifying the object to any value other than charT() leads to undefined behavior.

   
   

str[str.size()] basically points to the null-terminator character. You can read and write it, but you may only write a null into it.

The operator expects pos to be less than or equal to size(), so if it is not less, then it is expected to be equal.

Additionally to the previous answers please take a look at the libcxx (the llvm implementation) defines std::string::operator like:

template <class _CharT, class _Traits, class _Allocator>

inline

typename basic_string<_CharT, _Traits, _Allocator>::const_reference

basic_string<_CharT, _Traits, _Allocator>::operator(size_type __pos) const _NOEXCEPT

{

    _LIBCPP_ASSERT(__pos <= size(), "string index out of bounds");

     return *(data() + __pos);

}



template <class _CharT, class _Traits, class _Allocator>

inline

typename basic_string<_CharT, _Traits, _Allocator>::reference

basic_string<_CharT, _Traits, _Allocator>::operator(size_type __pos) _NOEXCEPT

{

    _LIBCPP_ASSERT(__pos <= size(), "string index out of bounds");

    return *(__get_pointer() + __pos);

}

Take a look at the .at() that properly throws instead.

template <class _CharT, class _Traits, class _Allocator>

typename basic_string<_CharT, _Traits, _Allocator>::const_reference

basic_string<_CharT, _Traits, _Allocator>::at(size_type __n) const

{

    if (__n >= size())

        this->__throw_out_of_range();

    return (*this)[__n];

}

As you can, in the first case, there is a runtime assert(thanks t.niese for pointing out) which is triggered only in debug mode whereas the second will always throw, regardless of the build options of the library.