Hi!

   I need a routine like:

std::string nth_word(const std::string &s, unsigned int n) {
   // return n-th word from the string, n is 0-based
   // if 's' contains too few words, return ""
   // 'words' are any sequences of non-whitespace characters
   // leading, trailing and multiple whitespace characters
   // should be ignored.
   // eg. "These  are     four\t\twords\t\t".

std::string nth_word(const std::string& source, unsigned int n) {
   // the addition of " " allows for the extraction of the last
   // word, after which ss would go eof() below if not for the space
   stringstream ss(source+" ");
   string s;
   for(unsigned int k=0;k<=n;k++) {
     ss >> s;
     if(!ss.good()) return ""; // eof
   }
   return s;

   I'm thinking of a combination of find_first_not_of and
find_first_of, but before I code it, perhaps somebody can
comment on this? I have a gut feeling that some nasty
strtok hack would be even faster, would it? Or is there
perhaps some other, performance-oriented way like traversing
s.c_str() with a pointer and memcpying out the relevant part?

Nothing like a state machine.

// warning - brain dump - not compiled ever - not tested - use at your
own peril

#include <cctype>

std::string nth_word(const std::string& source, unsigned int n)
{

     enum state_type { inspace, inword };

     std::string::const_iterator        l_iter = source.begin();
     const std::string::const_iterator  l_end = source.end();

     if ( l_end == l_iter )
     {
         return "";
     }
     std::string::const_iterator        l_beg_word = l_iter;

     state_type state = ( std::isspace( * l_iter ) ) ? inspace : inword;

     int word_count = state == inspace ? 0 : 1;

     ++ l_iter;

     while ( l_end != l_iter )
     {

          switch ( state )
          {
               case inspace :

                     if ( std::isspace( * l_iter ) ) break;
                     state = inword;
                     l_beg_word = l_iter;
                     ++ word_count;
                     break;

               case inword :

                     if ( ! std::isspace( * l_iter ) ) break;
                     state = inspace;

                     if ( n == word_count )
                     {
                           return std::string( l_beg_word, l_iter );
                     }
                     break;
          }

          ++ l_iter;
     }

     switch ( state )
     {
          case inspace :
                return "";
          case inword :
                if ( n == word_count )
                {
                     return std::string( l_beg_word, l_iter );
                }
                return "";
     }

     return "";