Thread: Exercise 3-3 in Accelerated C++

Okay, so I looked at the solution which is what I'm assuming you looked at. I'm actually reading this book too and I didn't even know they had full solutions. Talk about a useful reference lol.

Anyway, this code,

Code:

typedef vector<string>::size_type vec_sz;
vec_sz size = words.size();

simply redefines "vector<string>::size_type" to the declaration "vec_sz". Look at this link, vector - C++ Reference and you'll see that the member size_type is usually the same as size_t but instead of being applicable to anything, it's specifically made for vectors. I'm actually not sure how this part really works because you could just use the sizeof() operator but w/e. Basically, size_type seems to be the unit size of each element of the vector.

Idk what your second question is asking. But the .begin() and .end() member functions return iterators to the beginning and end of the vector.

Now, as for the program itself. When you sort a vector of strings, the library was written to automatically sort by alphabetical order. So, what this code does is, it points to the first element of the vector and then begins examining every element but that one. If the next element is not the exact same then we know for sure that the word was only repeated once. So it then resets the iterator to the next element and then continues checking every element after.

Code:

for (vec_sz current_index = 1; current_index < size; ++current_index)
   { 
      if (current_word != words[current_index])
      {
         cout << "The word \"" << current_word << "\" appears "
            << count << " times." << endl;


         current_word = words[current_index];
         count = 0;
      }


      ++count;
   }

Here you can see that our first current_word is words[0]. It's redundant to compare this to words[0] so we start off at index 1 and we will iterate over the range less than size. So, if current_word is not equal to next index then we know it is not repeated so we print out some useful information and reset the counter. If the next word is the same then we simply add 1 to the count and then check the following indices.

Here's what words would look like sorted, ( Na, goodbye, hey, hey, na, na, na ).

The loop starts off at Na and compares it to goodbye. They are not the same so we print and then reset the current_word to the next word in the vector. Now we start off at goodbye. The next word is "hey" which is not the same so print and reset current_word to the first "hey". We point at "hey" and the next word is "hey" so we increase the count and check the index after the second "hey". Note that it is the first "hey" that is being compared to the first "na" as current_word was NOT updated. current_word is only changed in the if-block.

So we find that "hey" is not "na" so we reset current_word to the position where the inequality was found (at the first "na") and continue looking from there. Note that it's the same here, the first "na" is compared to the last two "na"s and our loop finally breaks when the current_index exceeds the length of the vector.

I hope this helped.

Edit: And the last part is a safe-guard against the breaking condition of the loop occurring before the inequality within the loop happens. Notice that the loop ends before the code has a chance to get to an index where the first "na" does not equal some other element of it so the external print is simply a safe guard against that and will print w/e was left over from the loop.

I'm actually not sure how this part really works because you could just use the sizeof() operator but w/e. Basically, size_type seems to be the unit size of each element of the vector.

size_type is a typedef present in all STL containers, it is supposed to represent the type best used to keep track of the size of said container. Usually it is simply a size_t but you should prefer to use the typedef in case this changes in the future.

*2 - Is it possible to call these .begin() and .end() values for output or a statement or do I must first put them in something a type string or type int if it were a number?

begin() and end() return iterators to the beginning and end of the container, if you need to access the elements at these positions you must first dereference the iterators like so:

Code:

std::cout << *(vec.begin()) << std::endl;

MutantJohn, Thanks that actually helped a lot. Breaking it down made me realize what I should have caught earlier. I was confused because I thought the code was comparing current_word with all the words in the vector but in reality, all it does is compare itself with the next word. So if your input was "goodbye hello hello goodbye" The output would say "goodbye was counted once, hello twice, goodbye once" I thought the program was supposed to say "good by twice, hello twice"