A Unique Word Counter

• This took us months to do in 230.
• Can we use the tools of c++ to speed this up?
• First I want to build a class:
  • A WordT is responsible for holding a word and a count of the number of times the word appeared.
  • 
  • Overload ==, just compare words.
  • Overload <, if the count is the same compare words, otherwise compare counts (>)
  • Overload Word
    • If passed nothing, it returns the string
    • Id passed a string, it stores the string and sets the count to 1
  • Increment and Count are for accessing the count field.
  • We could make it responsible for stripping words, I didn't in my test case, but if you want to, we can.
  • Is this a good class?
• We can overload other operators as well.
  • The stream insertion operator
    • Takes
      • an output stream reference
      • And an item to print
    • Returns an output stream reference.

  • ostream & operator << (ostream & s, const WordT & word){
         s << word.Word() << " " << word.Count();
         return s;
    } 

• The key thing is to illustrate a vector of these items
  • vector<WordT> words;
  • I can pass this to a function if I wish

    • void ReadWords(ifstream & inFile, vector<WordT> & words);
                    

  • Or if I wish I can use a typedef or using statement.
    • Old Style:

      • typedef vector<WordT> WordVectorT; 

    • New Style:

      • using WordVectorT = vector;

    • In either case

      • WordVectorT words;
        WordVectorT::iterator pos;
        ReadWord(ifstream & inFile, WordVectorT & words); 

• But what is this iterator thing?
  • This is chapter 17, give it a read. (At least through 610)
  • Iterators allow us to step through a standard container
  • They are very powerful.
  • Think of them as a pointer type
  • There are several variations
  • For now, let's deal with a simple iterator.

    • vector <WordT>::iterator pos; 

    • pos can now point to any element of a vector of WordT's
    • Assume words is such a vector.
    • words.begin() or begin(words) returns an iterator to the first element.
    • words.end() or end(words) returns an iterator to one past the last element.

    • for(pos = begin(words); pos != end(words); pos++) {
         cout <<setw(20) << pos->Word() << " " << pos->Count() << endl;
      } 

      • But if I try to pass the word list by constant reference I get in trouble with the compiler.
      • So a const_iterator is available.

        • void PrintList(const vector <WordT> & words){
              vector <WordT>::const_iterator pos;
          
              for(pos = cbegin(words); pos != cend(words); pos++) {
                 cout <<setw(20) << pos->Word() << " " <<<pos->Count() << endl;
              } 

    • There are also type::reverse_iterators
    • There are also type::const_reverse_iterators
    • These point to rbegin(var), or var.rbegin()
    • These point to crbegin(var), or var.crbegin()
    • These point to rend(var), or var.rend()
    • These point to crend(var), or cvar.rend()
  • Increment operators work as expected
  • You can also do math and comparison.
• We need iterators for the standard algorithm library.
  • #include<algorithm>
  • We will use two algorithms for this code
  • find(beginning iterator, ending iterator, item)
    • The ending iterator points one past the end of the range.
    • [begin, end) in math notation.
    • The return value is an iterator to
      • The item if it is found using == operator
      • The end element if it is not found.
  • sort(beginning iterator, end iterator)
    • This will call an $O(n \log n)$ sort