Palindrome evaluator in C++
Your code looks so good, it is quite impressive of you were learning c++ few days ago. i'm sure you will get a decent code-review but here my humble attempt.

It always preferred to pass the std::string by const reference if you don't  modify it. also, std::vector is preferred over std::list. here link for more details 

In your read function. It redirects all input into this container until EOF is received. However, the used container might need to reallocate memory too often, or you will end with a std::bad_alloc exception when your system gets out of memory. In order to solve these problems, you could reserve a fixed amount N of elements and process these amount of elements. here an alternative example to your read function by using std::copy_n and std::istream_iterator like so,

words.reserve(N);
std::copy_n(std::istream_iterator&lt;std::string&gt;(std::cin),
    N,
    std::back_inserter(words));


In your evaluate function, it is fine but not efficient doe to the call of std::string constructor in every iteration along with deleting un-palindrome elements. it is better to create another container for palindrome elements and check the main container elements if it has palindrome element. possible implementation:

std::vector&lt;std::string&gt; palindromes;
for (const auto&amp; word : words)
{
    if(is_palindrome(word))
        palindromes.emplace_back(word);
}


The is_palindrome function, we test the given string for whither it is palindrome or not, like so:

bool is_palindrome(const std::string&amp; str)
{
    if (str.empty())
        return false;

    using str_sz = std::string::size_type;
    for (str_sz i = 0, j = str.length() -1; i &lt; j ; ++i, --j)
    {
        if (str[i] != str[j])
            return false;
    }
    return true;
}


thanks to @screwnut for suggesting to std::copy_if instead of for-range while the for-loop is bit clear and simple. but std::copy_if will allow us to use lambda instead of calling is_palindrome function, that might be helpful if you simply write it like this:

std::copy_if(words.begin(), words.end(), 
             std::back_inserter(palindromes), 
             [](const std::string&amp; str)
             {return std::equal(str.begin(), str.begin() + str.size() / 2, str.rbegin());});


Lastly, for longest string, you may take advantage of STL by using std::max_element which is return iterator.

std::max_element(palindromes.begin(), palindromes.end(),
    [](const std::string&amp; lhs, const std::string&amp; rhs)
{
    return lhs.size() &lt; rhs.size();
});


put all to gather:

#include &lt;iostream&gt;
#include &lt;vector&gt;
#include &lt;algorithm&gt;
#include &lt;iterator&gt;

int main()
{
    const std::size_t TotalWords = 3;
    std::vector&lt;std::string&gt; words;
    words.reserve(TotalWords);

    std::cout &lt;&lt; "Please enter some words." &lt;&lt; std::endl;
    std::istream_iterator&lt;std::string&gt; in(std::cin);
    std::copy_n(in, TotalWords, std::back_inserter(words));

    std::vector&lt;std::string&gt; palindromes;

    auto comp = [](const std::string&amp; str)
    {
        return std::equal(str.begin(), str.begin() + str.size() / 2, str.rbegin());
    };

    std::copy_if(words.begin(), words.end(), std::back_inserter(palindromes), comp);

    if (palindromes.empty())
    {
        std::cout &lt;&lt; "No palindromes were given" &lt;&lt; std::endl;
    }
    else
    {
        auto longest = std::max_element(palindromes.begin(), palindromes.end(),
            [](const std::string&amp; lhs, const std::string&amp; rhs)
        {
            return lhs.size() &lt; rhs.size();
        });
        std::ostream_iterator&lt;std::string&gt; out(std::cout, "\n ");
        std::cout &lt;&lt; "Palindromes: \n ";
        std::copy(palindromes.begin(), palindromes.end(), out);
        std::cout &lt;&lt; "\rLongest: " &lt;&lt; *longest &lt;&lt; std::endl;
    }
}