Вывести те слова предложения, которые отличны от последнего слова предложения и удовлетворяют следующему свойству:

#include <iostream>
#include <fstream>
#include <vector>
#include <string>
#include <cctype> // ispunct isspace isalnum
 
template<typename _Ty>
struct Pair
{
    _Ty first;
    _Ty second;
};
 
template< class InputIt, class UnaryPredicate >
    InputIt find_if(InputIt, InputIt, UnaryPredicate);
template<typename _Iter>
    Pair<_Iter> FindWord(_Iter, _Iter);
template<typename _Iter>
    _Iter FindSentence(_Iter, _Iter);
template<typename _Iter>
    typename std::iterator_traits<_Iter>::difference_type Difference(_Iter, _Iter);
bool IsSymbolWord(const char&);
bool IsDelim(const char&);
bool IsDelimSentence(const char&);
 
enum : std::string::size_type { MAX_ROWS = 10, MAX_CHAR_STR = 80};
 
int main()
{
    std::fstream infile{ "input.txt", std::ios_base::in };
    if (!infile.is_open())
    {
        std::cout << "Input file not found!" << std::endl;
        return 1;
    }
    else
    {
        std::string str{};
        str.reserve(MAX_ROWS * MAX_CHAR_STR + MAX_ROWS + 1); // Резервируем память
        {
            // Считываем все строки и конектим их к str через пробел
            std::string buffer{};
            while (std::getline(infile, buffer))
            {
                str += buffer;
                str.push_back(' ');
            }
        }
        std::string::const_iterator beg_sentence{ str.cbegin() }, end_sentence{ str.cbegin() };
        std::fstream outfile{ "output.txt", std::ios_base::out | std::ios_base::trunc };
        while (end_sentence != str.cend()) // Пока есть предложения...
        {
            end_sentence = FindSentence(beg_sentence, str.cend()); // Ищем конец предложения
            std::vector<Pair<std::string::const_iterator>> data; /// Вектор для хранения слов предложения
            std::string::const_iterator beg_word{ beg_sentence };
            while (beg_word != end_sentence) // Пока есть слова...
            {
                Pair<std::string::const_iterator> temp = FindWord(beg_word, end_sentence); // Ищем слово в найденом предложении
                if (temp.first != temp.second) // Если это слово...
                {
                    data.push_back(temp); // добавляем его в вектор
                }
                beg_word = temp.second;
            }
            bool isPrint{}; // Был ли вывод результата?
            if (data.size() > 1)
            {
                std::string::difference_type length_back_word{ Difference(data.back().first, data.back().second) }; /// Длина последнего слова
                for (decltype(data)::size_type i{}; i < (data.size() - 1); ++i) // Перебираем все слова кроме последнего...
                {
                    if (Difference(data[i].first, data[i].second) == length_back_word) // Если длины одинаковы...
                    {
                        if (!isPrint) // Если вывода не было...
                        { // Выводим последнее слово
                            const std::string temp_str { data.back().first, data.back().second };
                            std::cout << temp_str << ": ";
                            outfile << temp_str << ": ";
                            isPrint = true;
                        }
                        // Выводим подходящие слова
                        std::cout << std::string{ data[i].first, data[i].second } << ' ';
                        outfile << std::string{ data[i].first, data[i].second } << ' ';
                    }
                }
            }
            if (isPrint) // Если был вывод...
            { // Делаем перенос строки
                std::cout << std::endl;
                outfile << std::endl;
            }
            beg_sentence = ((end_sentence != str.cend()) && ((end_sentence + 1) != str.cend())) ? end_sentence + 1 : end_sentence;
        }
    }
}
 
template<class InputIt, class UnaryPredicate>
InputIt find_if(InputIt first, InputIt last, UnaryPredicate p)
{
    for (; first != last; ++first)
    {
        if (p(*first))
        {
            return first;
        }
    }
    return last;
}
 
template<typename _Iter>
Pair<_Iter> FindWord(_Iter First, _Iter Last)
{
    Pair<_Iter> res{};
    res.first = find_if(First, Last, IsSymbolWord);
    res.second = find_if(res.first, Last, IsDelim);
    return res;
}
 
template<typename _Iter>
_Iter FindSentence(_Iter First, _Iter Last)
{
    return find_if(First, Last, IsDelimSentence);
}
 
bool IsSymbolWord(const char &Ch)
{
    return std::isalnum(Ch);
}
 
bool IsDelim(const char &Ch)
{
    return (std::isspace(Ch) || std::ispunct(Ch));
}
 
bool IsDelimSentence(const char &Ch)
{
    return (Ch == '.' || Ch == '!' || Ch == '?');
}
 
template<typename _Iter>
typename std::iterator_traits<_Iter>::difference_type Difference(_Iter First, _Iter Last)
{
    return (Last - First);
}