A First Step

Let's take a first step at the bigger processing for this problem.
- This will not be our final solution.
- In fact, I want to think about this as a procedural programmer
- In the next set of notes we will take an object oriented approach.
So the first thing we need to do is declare the data structure to hold all of the words.
- This is an array of WordT
- But I have a problem here. How big
  - For now, we just declare a "big enough" size.
  - If in the future we find this is insufficient we will need to recompile.
  - This isn't ideal, but it will do for now.
- This brings up a new idea.
  - The array has a capacity or the maximum number of elements it can hold.
  - It also has a size or the actual number of elements it is currently holding.
  - There are elements beyond the size, but these are not valid elements.
- In general we let size be the number of elements.
  - Initially size is 0, since there are no elements in the array.
  - size can be at most capacity, as that is the last available element.
  - In normal processing, the only valid elements are between 0 and size.
  - By the way, don't worry about "erasing" elements bigger than size.
- This leads to a new thought, where do we put the next item?
  - The way we have set size up means that the next available empty space in the array is at array[size].
  - We insert elements here, but only if size is less than capacity.
  - We then increment size.

Let's make a first pass at adding this.

Set CountWords.cpp up to use the new WordT
- Include it in WordCount.cpp
- In the Makefile change the dependency line for WordCount

In the main

Add a new array of WordT.
Add a size_t wordCount which is initialized to 0.

int main() {
    bool done{false};
    ActionT action{ActionT::QUIT};
    WordT  words[MAX_WORDS];
    size_t wordCount{0};

ReadWords needs to be modified
- What parameters should we pass and how should we pass them?
  - The array
  - We will also want to pass the size (wordCount)
    - This will be changing so we want to pass it by reference.
  - ```
  void ReadWords( WordT words[], size_t & wordCount); 
```
- The function will develop over several steps.
  - To avoid the end of file loop we need
  - ```
  inFile >> word;
  while (inFile) {
      words[wordCount].SetWord(word);
      wordCount++;
  
      inFile >> word;
  } 
```
- But there is more to it than this.
- We better check to make sure we don't go out of bounds.
- ```
inFile >> word;
while (inFile) {
    if(wordCount < MAX_WORDS) {
        words[wordCount].SetWord(word);
        wordCount++;
    }  else {
        // error message about array capacity
    }

    inFile >> word;
} 
```
  - There are other issues, but I would like to test first.

Let's write a quick PrintWords function

What should the parameters to PrintWords be and why?
Here is my function

void PrintWords(const WordT words[], size_t wordCount){
    size_t i;

    for(i = 0; i < wordCount; i++) {
        cout << setw(20) << words[i].GetWord()
             << setw(10) << words[i].GetCount() << endl;
    }
    cout << endl;
}

I modified the main to look like this

    ReadWords(words, wordCount);
    while (not done) {
        PrintWords(words, wordCount);
        action = GetUserAction();
        PerformUserAction(action, done);
    }

We still have a few issues.

We need to clean up the words
- This is really only two function calls, Strip and MakeLower
- But it might change in the future.
- And ReadWords is getting big
- So I added a function FixWords(string & word)

Now, however, I am inserting blank words

Is there a bug? Why am I getting blank words?
I could wrap the code inside of an if statement
But the logic is getting too deep
So I am going to make a new function, InsertWord
This is just the inside part of the while loop
But that loop is becoming complex.
Insert Word becomes

void InsertWord(string word, WordT words[], size_t & wordCount) {

    FixWord(word);

    if (word != "") {
       if (wordCount < MAX_WORDS) {
            words[wordCount].SetWord(word);
            wordCount++;

       } else {
            cout << "The array is full, can not insert another word" << endl;
       }
    }
    return;
}

And read words becomes

void ReadWords( WordT words[], size_t & wordCount){
    string  fileName;
    ifstream inFile;
    string word;

    fileName = GetFileName();
    inFile.open(fileName);

    if (inFile) {
        wordCount = 0;

        inFile >> word;
        while (inFile) {
            InsertWord(word, words, wordCount);
            inFile >> word;
        }
        inFile.close();
    }

    return;
}

Now we are mostly good, we still need to increment the word cout for words in the array.
- A simple linear, or sequential search will solve this problem.
- It takes:
  - The array
  - The size of the array
  - And the word we are looking for
    - This is often called the key
- It returns
  - The position in the array of the word.
  - But what do we do if the word is not found?
  - In this case I decided to return the size.
    - That way I can keep the return type a size_t
    - It clearly indicates that the element is not in the size of the current array.
    - And it is not limited by some artificial constant.
- I built a find function
- ```
size_t FindWord(WordT words[], size_t wordCount, string key) {
    size_t i;

    i = 0;
    while (i < wordCount and words[i].GetWord() != key) {
       i++;
    }

    return i;
} 
```
- Notice
  - Short circuit evaluation means it will never index to words[wordCount]
With this addition, InsertWord becomes

void InsertWord(string word, WordT words[], size_t & wordCount) {
    size_t pos;

    FixWord(word);

    if (word != "") {
       pos = FindWord(words, wordCount, word);

       if (pos < wordCount) {
           words[pos].IncrementCount();

       } else if (wordCount < MAX_WORDS) {
            words[wordCount].SetWord(word);
            wordCount++;

       } else {
            cout << "The array is full, can not insert another word" << endl;
       }
    }
    return;
}