For your consideration, std::replace. See if you can figure out a good place to use it [smile]

Quote:Original post by visitor
I wonder why you accept a whole string and not a single character for input.

I'd accept a whole string from the input, much the same way as it's being done now using std::getline but then validate that it has a length of one. That way if the user does enter multiple chars instead of just one then not only will they all get pulled from the stream but the user can be informed of their mistake.

Quote:Original post by agm_ultimatex

Quote:Original post by dmatter
I'd accept a whole string from the input, much the same way as it's being done now using std::getline but then validate that it has a length of one. That way if the user does enter multiple chars instead of just one then not only will they all get pulled from the stream but the user can be informed of their mistake.

Thats a good idea for an error check thanks. I didnt use a char cause it didnt really fix any problems i had, so i went back to string, as I like them.

You could probably do better than that really: Let the user type multiple characters if they want to and handle it intuitively by searching for each of the characters one by one. In other words, set aside the fact the player has a limited number of lives, if they were type all the letters from a-z and press enter then it would always solve the word/game. This is most convenient near the end of the game where the user might have guessed the word before having all the letters; they can either type the word, or just the remaining letters, and win more speedily.

std::replace() is intended to be used with a range. Ranges can be obtained from C++ Standard Library containers (you can think of a string as a container designed with character operations in mind) by calling their begin() and end() member functions.

Lets read the description of std::replace()

Quote:
Replace replaces every element in the range [first, last) equal to old_value with new_value

The notation [first, last) denotes a "half open range". In other words, this means that "first" is included in the range, but "last" is not. The range [a, e) over the alphabet is "a, b, c, d". This may seem at odd way to think at first, but remember that a half open range is the most natural way of writing a for loop in C++:

In the C++ Standard Library usage of range, we mean a range of elements. In this case, we are talking about the characters in the string. We note that the begin() member function of the std::string class gives us an "iterator" to the start of the range defining the string. The end() member function gives us an iterator that is one past the end of the string.

Graphically, if our string were "Hello, World":

Hello, World^           ^begin       end

As you should be able to see, looping over the half open range [begin, end) will visit each character in the string.

An iterator is a type that allows us to inspect or modify the value of each element as we loop over a range.

For example, consider the following:

We can note that some of the things that the standard string iterator allows us to do is compare them against each other (the it != string.end() part), advance the iterator to the next element (the ++it part) and to inspect the value (the *it part). In this case I have used a "const_iterator" because I am not intending to modify the string.

Let us consider an example that modifies the string:

As you can see, we are now allowed to assign to the dereferenced iterator, allowing us to modify the string. If you had made "it" a "const_iterator", this would not have compiled.

Finally, back to std::replace. It goes through the half open range that you pass to it, and replaces any element equal to "old_value" with the element "new_value". That is, it could be written like this:

It may seem like overkill, but there is method in the madness [smile]. A great many manually written loops in C++ programs can be eliminated in favour of such algorithms. This can help increase the clarity of the code, as well as reduce the amount of code written.

That said, I may have spoken too soon when I suggested that std::replace could be used for that loop, its actually a more complicated algorithm called replace_copy (as we have two strings, theWord and displayWord). However, even that may not be the algorithm you eventually want (because you only want to conditionally replace the characters). My apologies about leading you astray with that [embarrass].

While the C++ Standard Library does have a nice algorithm to handle that, I won't go into it yet, unless of course you are interested. But I really think you should finish your game first.