Searching for pseudo-palindromes ("semordnilaps")
I'd try to break some habits, and make others in their places.


One habit to break is using while (!file.eof()) -- it's nearly always a problem (including this time).
In its place, I'd consider initializing the array of input strings from a pair of std::istream_iterators.
I'd try to form the habit of creating fstream objects initialized with the name of the name of the file you want to read/write, rather than creating an uninitialized object, then using open open the file afterwards.
I'd also try to get in the habit of using better/more efficient data structures when possible. As pointed out below, in this case it doesn't make a big difference, but it does help a little, and it actually simplifies the code--a clear win.
Finally, get in the habit of using standard algorithms where they apply. In this case, I think a non-standard algorithm really makes more sense--a transform_if, which I end up using quite a bit, as a matter of fact.


Putting these together, we could end up with something on this order:

#include &lt;iostream&gt;
#include &lt;unordered_set&gt;
#include &lt;string&gt;
#include &lt;iterator&gt;
#include &lt;fstream&gt;
#include &lt;algorithm&gt;

template &lt;class InIt, class OutIt, class F, class P&gt;
void transform_if(InIt b, InIt e, OutIt o, P p, F f) { 
    while (b != e) { 
        auto v = f(*b);
        if (p(v))
            *o++ = v;
        ++b;
    }
}

int main(){ 
    std::ifstream in("us.dic");
    std::unordered_set&lt;std::string&gt; words{
        std::istream_iterator&lt;std::string&gt;(in), 
        std::istream_iterator&lt;std::string&gt;()};

    std::vector&lt;std::string&gt; reversed;
    transform_if(words.begin(), words.end(), 
        std::back_inserter(reversed),
        [&amp;](std::string const &amp;s) { return words.find(s) != words.end(); },
        [](std::string const &amp;s) { return std::string(s.rbegin(), s.rend()); });

    std::sort(reversed.begin(), reversed.end(),
        [](std::string const &amp;a, std::string const &amp;b) {
            if (a.length() &lt; b.length())
                return true;
            return a &lt; b;
        });
    for (auto const &amp;s : reversed)
        std::cout &lt;&lt; s &lt;&lt; "\n";
}


I haven't tried to move much out of main, because in this case we've already reduced main to only 6 statements (though, admittedly, some of those are fairly long).

A few other miscellaneous points:


I'd prefer to see #include directives formatted with a space before the header name (as I've done in my code above).
Using an unordered_set helps the run time somewhat, but not drastically--on my machine, the CPU time is reduced from ~.35 seconds to ~.24 seconds. That's clearly faster, but not immensely so.
Another possibility to consider would be to put the inputs into a sorted vector, but use an interpolation search instead of a binary search to find the pseudo-palindromes.