Anagram solver in C++ - c++

Question

I am working on a project for school and I am stuck on what I believe is just a small part but I cant figure it out.
Here is what I have so far:
#include <iostream>
#include <fstream>
#include <string>
#include <locale>
#include <vector>
#include <algorithm>
#include <set>
using namespace std;
int main(int argc, char* argv[])
{
set<string> setwords;
ifstream infile;
infile.open("words.txt"); //reads file "words.txt"
string word = argv[1]; // input from command line
transform(word.begin(), word.end(), word.begin(), tolower); // transforms word to lower case.
sort(word.begin(), word.end()); // sorts the word
vector<string> str; // vector to hold all variations of the word
do {
str.push_back(word);
}
while (next_permutation(word.begin(), word.end())); // pushes all permutations of "word" to vector str
if (!infile.eof())
{
string items;
infile >> items;
setwords.insert(items); //stores set of words from file
}
system("PAUSE");
return 0;
}
Now I need to compare the words from the file and the permutations stored in vector str
and print out the ones that are real words.
I know I need to use the find method of the set class. I am just not sure how to go about that. I was trying something like this with no luck, but my thought process is probably wrong.
for (unsigned int i = 0; i < str.size(); i++)
if (setwords.find(word) == str[i])
cout << str[i] << endl;
If you guys could help or point me in the right direction I would greatly appreciate it.

Answer 1

First, I'd like to say that this is a well-asked question. I appreciate new users that take the time to articulate their problem in detail.
The problem is that the find() method of a std::set<> returns an iterator object pointing to the value that it finds, or the end() of the container if it can't. When you compare it with str[i] (a string) it can't find a suitable overload of operator==() that takes both the iterator and a string.
Instead of making a full-on comparison with the string, you can instead compare the return value with end() to determine if it found the string:
if (setwords.find(str[i]) != setwords.end())
// ^^^^^^ ^^^^^^^^^^^^^^
If the expression returns true, then it sucessfully found the string inside the set.
There's also another potential problem I'd like to address in your code. Using if (!file.eof()) is the wrong way to condition your input. You should instead make the extract part of the condition, like this:
for (std::string item; infile >> item; )
{
setwords.insert(item);
}
Here's another way, using std::istream_iterator<>:
setwords.insert(std::istream_iterator<std::string>(infile),
std::istream_iterator<std::string>());

Answer 2

You actually are really close to having it right.
The set::find method doesn't return the value if it is found in the set, but rather an iterator object that points to the value. So your if statement is comparing the current string to the returned iterator object instead of the value that the iterator points to.
To get the value than an iterator points to, you just have to dereference it like you would a pointer, by prefixing it with an asterisk. Which means that you probably intended your if statement look like this:
if (*(setwords.find(word)) == str[i])
This would work for cases where the value was found in the set, but would be problematic for cases where the value was not found. If the value is not found, an iterator that points to the position after the last item in the set is returned - and you shouldn't try to dereference such an iterator (because it doesn't point to a valid object).
The way these checks are usually conducted is by comparing the returned iterator with the iterator that points to the end of the set (e.g., set::end, in this case). If the iterators do not match, that means the item was found.
if (setwords.find(word) != setwords.end())
cout << word << endl;

Answer 3

I think you need to write something like this:
for (unsigned int i = 0; i < str.size(); i++)
if (setwords.find(str[i]) != setwords.end())
cout << str[i] << endl;
But I think you don't need to store all permutations. You can store set of words with sorted letters. And compare it with sorted word.....
here is simpler solution
#include <iostream>
#include <fstream>
#include <string>
#include <locale>
#include <vector>
#include <algorithm>
#include <map>
using namespace std;
int main(int argc, char* argv[])
{
map<string, string> mapwords;
ifstream infile;
infile.open("words.txt"); //reads file "words.txt"
string word = argv[1]; // input from command line
transform(word.begin(), word.end(), word.begin(), tolower); // transforms word to lower case.
sort(word.begin(), word.end()); // sorts the word
if (!infile.eof())
{
string item;
infile >> item;
string sorted_item = item;
sort(sorted_item.begin(), sorted_item.end()); // sorts the word
mapwords.insert(make_pair(sorted_item, item)); //stores set of words from file
}
map<string, string>::iterator i = mapwords.find(word);
if(i != mapwords.end())
cout << i->second << endl;
system("PAUSE");
return 0;
}