How is std::cin >> std::string implemented?

Question

In particular, how do the code check if memory for chars should be reallocated? Or how many chars the user entered? If I wanted to assign a C-string's value to my implementation of a string class I would probably do something like this

   String& operator=(String& to, const char *from)
   {
      if((strlen(from) + 1) > to.size) {
        if (to.str != NULL) {
          delete[] to.str;
          to.str = NULL;
        }
        to.size = strlen(from) + 1;
        to.str = new char[to.size];
      }
      strcpy(to.str, from);
      return to;
    }

Easy enough. But the operator>> of the std::string is really making me curious.

Answer 1

Fundamentally, the implementation looks something like this (ignoring the fact that both the streams and the string are templates):

std::istream& operator>> (std::istream& in, std::string& value) {
    std::istream::sentry cerberos(in);
    if (cerberos) {
        value.erase();
        std::istreambuf_iterator<char> it(in), end;
        if (it != end) {
            std::ctype<char> const& ctype(std::use_facet<std::ctype<char> >(in.getloc()));
            std::back_insert_iterator<std::string> to(value);
            std::streamsize n(0), width(in.width()? in.width(): std::string::max_size());
            for (; it != end && n != width && !ctype.is(std::ctype_base::space, *it); ++it, ++to) {
                *to = *it;
            }
        }
    }
    else {
        in.setstate(std::ios_base::failbit);
    }
    return in;
}

A reasonable implementation would probably use an algorithm which would process the content of the stream buffer's buffer segment-wise, e.g., to avoid the repeated checks and calls to is() (although for the std::ctype<char> it is really just applying a mask to an element of an array). In any case, the input operator wouldn't faff about allocating memory: a typical case "not my job".

Answer 2

I believe it must use some sort of smart memory allocation management. If you are familiar with c, you would have seen the function realloc. My thought is that most container classes in the stl internally use some form of realloc to allocate more memory to themselves.

To to answer your question, the string class is typedef'd from another class: std::basic_string<char> which is basically an array of char. So internally it has reserved memory that can grow or shrink depending on the user's preferences or needs. And like I mentioned before this memory management is done in a way that is optimal and safe so that information is not lost.

If I were to implement std::cin >> std::string it will be in the form of a for loop that iterates through the array of char and assigns a value to each character in the array