Lecture Notes for CS 509, Advanced Programming II

30 March 2004, Splitting Strings

Koenig and Moo Split a String

typedef std::vector strvec
typedef std::string::size_type   str_indx

strvec
split(const std::string & s) 

  strvec words
  str_indx b = 0

  while b != s.size()
    while (b != s.size()) and isspace(s[b])
      ++b

    str_indx e = b
    while (e != s.size()) and !isspace(s[e])
      ++e

    if b != e
      words.push_back(s.substr(b, e - b))
      b = e
      
  return words

• Use informative variable names.

  • b, not i; e, not j; words not ret.

Know Your Tools

• The string data type supports many of these operations.

  strvec
  split(const std::string & str) 
  
    strvec words
    str_indx b = 0
    const char * const space = " \t\n"
  
    while true
      b = str.find_first_not_of(space, b)
      if (b == eostr) break
  
      const str_indx e = 
        str.find_first_of(space, b)
  
      words.push_back(str.substr(b, e - b))
      b = e
  
    return words
  

• Member functions usually are more efficient than the associated generic algorithms.

  • More knowledge = better code.

Being Generic

• Koenig and Moo reconsider on page 156.

  template < typename Out >
  void split(const std::string & str, Out oi) 
  
    typedef string::const_iterator str_citer
  
    str_citer s = str.begin()
  
    while true
      s = find_if(s, str.end(), isnotspace)
      if (s == str.end()) break
  
      const str_citer e = 
        std::find_if(s, str.end(), isspace)
  
      *oi++ = std::string(s, e)
      s = e
  

• This puts words in an arbitrary container.

  • It's used like this:

    strvec wds;
    split(s, std::back_inserter(wds));
    

Loops are Evil

• The presence of loops indicates the absence of generic algorithms.

  strvec
  split(const std::string & str) 
  
    std::istringstream iss(str)
    strvec words
  
    std::copy(std::istream_iterator(iss),
  	    std::istream_iterator(),
  	    std::back_inserter(words))
  
    return words
  

• The generic version is similar.

  template < typename Out >
  void split(const std::string & str, Out oi) 
  
    std::istringstream iss(str)
  
    std::copy(std::istream_iterator(iss),
  	    std::istream_iterator(), oi);
  

Prefer Member Functions

• Member functions are better suited then are generic algorithms.

  strvec 
  split(const std::string & str) 
  
    std::istringstream iss(str)
  
    return strvec(std::istream_iterator(iss),
  		std::istream_iterator())
  

• The generic version follows immediately.

  template < class Ctype >
  Ctype 
  split(const std::string & str)
  
    std::istringstream iss(str)
  
    return Ctype(std::istream_iterator(iss),
  	       std::istream_iterator())
  

  • It's used like this:

    strvec wds = split<strvec>(s);
    strlst wds = split<strlst>(s);
    

  See the complete code.

What's This Going to Cost?

Points to Remember

• "There is a better way - find it!" - Thomas Edison.

• Know your tools.

  • You can't expliot what you don't know about.

• Loops make you dizzy - good for roller coasters, bad for programmers.

  • Replace loops with generic algorithms.

• Prefer member functions to generic algorithms.

  • More knowledge == better code.

• Know what you're paying for.

  • Check your code to make sure.

This page last modified on 25 March 2004.