Как сделать проверку на наличие недопустимого слова?

#include <iostream>
#include <string>
#include <fstream>
#include <set>
#include <list>
#include <algorithm>
 
template<typename InIt, typename OutIt>
void split_mod
(
    InIt it_begin_s,
    InIt it_end_s,
    InIt it_begin_seps,
    InIt it_end_seps,
    OutIt it_out
);
 
int main()
{
    std::wcout.imbue(std::locale("rus_rus.866"));
    std::wcin.imbue(std::locale("rus_rus.866"));
    std::wstring seps(L" .,?!/\\\"|'~`@#№$;:%^*(){}[]<>-—+");
 
    //Белый список
    std::set<std::wstring> allowed_words{ L"hello", L"world" };
 
    std::wcout << L"Введите строку\n";
    std::wstring line;
    std::getline(std::wcin, line);
    std::list<std::wstring> words_in_line;
    split_mod(std::begin(line), std::end(line), std::begin(seps), std::end(seps), std::back_inserter(words_in_line));
    bool flag = true;
    setlocale(LC_CTYPE, "Rus");
    for (auto& word : words_in_line)
    {
        std::wstring word_down;
        std::transform(std::begin(word), std::end(word), std::back_inserter(word_down), ::towlower);
        if (!allowed_words.count(word_down))
        {
            setlocale(LC_CTYPE, "C");
            std::wcout << L"Ошибка. Слово \"" << word_down << L"\" не предусмотрено\n";
            flag = false;
            break;
        }
    }
    setlocale(LC_CTYPE, "C");
    std::wcout << (flag ? L"Текст содержит только допустимые слова\n" : L"");
 
    return 0;
}
 
template<typename InIt, typename OutIt>
void split_mod
(
    InIt it_begin_s,
    InIt it_end_s,
    InIt it_begin_seps,
    InIt it_end_seps,
    OutIt it_out
)
{
    if (!is_sorted(it_begin_seps, it_end_seps))
        sort(it_begin_seps, it_end_seps);
    using S = typename std::basic_string<std::iterator_traits<InIt>::value_type>;
    InIt it_old = it_begin_s;
    for (InIt it = it_begin_s; it != it_end_s; ++it)
        if (std::binary_search(it_begin_seps, it_end_seps, *it))
        {
            if (it_old != it)
                * it_out++ = S(it_old, it);
            it_old = it;
            std::advance(it_old, 1u);
        }
    if (it_old != it_end_s)
        * it_out++ = S(it_old, it_end_s);
}

#include <iostream>
#include <fstream>
#include <windows.h>
#include <string>
#include <vector>
#include <list>
#include <algorithm>
#include <optional>
 
std::vector<std::wstring> read_allowed_words_from_file(const std::wstring& path, std::wstring& seps);
 
std::optional<std::wstring> check_line(const std::vector<std::wstring>& allowed_words, std::wstring& line, std::wstring& seps);
 
template<typename InIt, typename OutIt>
void split_mod
(
    InIt it_begin_s,
    InIt it_end_s,
    InIt it_begin_seps,
    InIt it_end_seps,
    OutIt it_out
);
 
void wstring_towlower(std::wstring& str);
 
int main()
{
    SetConsoleCP(1251);
    SetConsoleOutputCP(1251);
    setlocale(LC_CTYPE, ".1251");
    std::wcout.imbue(std::locale("rus_rus.1251"));
    std::wcin.imbue(std::locale("rus_rus.1251"));
    std::wstring seps(L" .,?!/\\\"|'~`@#№$;:%^*(){}[]<>-—+\t");
    const std::wstring path(L"allowed_words.txt");
 
    /*
    //Создание файла *.txt в кодировке 1251, если такового не имеется
    std::wofstream wfout(path);
    wfout.imbue(std::locale("rus_rus.1251"));
    wfout << L"Заполитель\n";
    wfout.close();
    */
 
    //Белый список
    std::vector<std::wstring> allowed_words;
    try
    {
        allowed_words = read_allowed_words_from_file(path, seps);
    }
    catch (const wchar_t *err)
    {
        std::wcout << err << L"\n";
        return 1;
    }
    
    std::wcout << L"Введите строку\n";
    std::wstring line;
    std::getline(std::wcin, line);
    auto res = check_line(allowed_words, line, seps);
    std::wcout <<
        (!res ?
            L"Текст содержит только допустимые слова\n" :
            L"Ошибка. Слово \"" + *res + L"\" не предусмотрено\n")
        << L"\n";
 
    return 0;
}
 
std::vector<std::wstring> read_allowed_words_from_file(const std::wstring& path, std::wstring& seps)
{
    //Белый список
    std::vector<std::wstring> allowed_words;
    std::wifstream wfin;
    wfin.imbue(std::locale("rus_rus.1251"));
    wfin.open(path);
    if (!wfin.is_open())
    {
        throw L"Ошибка. Файл не удалось открыть\n";
    }
    std::wstring dump;
    for (; wfin.good();)
    {
        std::wstring line;
        std::getline(wfin, line);
        if (!line.empty())
        {
            dump += line + seps.front();
        }
    }
    wfin.close();
    split_mod(std::begin(dump), std::end(dump), std::begin(seps), std::end(seps), std::back_inserter(allowed_words));
    for (auto& word : allowed_words)
    {
        wstring_towlower(word);
    }
    std::sort(std::begin(allowed_words), std::end(allowed_words));
    auto new_end = std::unique(std::begin(allowed_words), std::end(allowed_words));
    allowed_words.erase(new_end, std::end(allowed_words));
    return allowed_words;
}
 
std::optional<std::wstring> check_line(const std::vector<std::wstring>& allowed_words, std::wstring& line, std::wstring& seps)
{
    std::list<std::wstring> words_in_line;
    split_mod(std::begin(line), std::end(line), std::begin(seps), std::end(seps), std::back_inserter(words_in_line));
    bool flag = true;
    for (auto& word : words_in_line)
    {
        wstring_towlower(word);
        if (!std::binary_search(std::begin(allowed_words), std::end(allowed_words), word))
        {
            return word;
        }
    }
    return {};
}
 
template<typename InIt, typename OutIt>
void split_mod
(
    InIt it_begin_s,
    InIt it_end_s,
    InIt it_begin_seps,
    InIt it_end_seps,
    OutIt it_out
)
{
    if (!is_sorted(it_begin_seps, it_end_seps))
        sort(it_begin_seps, it_end_seps);
    using S = typename std::basic_string<std::iterator_traits<InIt>::value_type>;
    InIt it_old = it_begin_s;
    for (InIt it = it_begin_s; it != it_end_s; ++it)
        if (std::binary_search(it_begin_seps, it_end_seps, *it))
        {
            if (it_old != it)
                * it_out++ = S(it_old, it);
            it_old = it;
            std::advance(it_old, 1u);
        }
    if (it_old != it_end_s)
        * it_out++ = S(it_old, it_end_s);
}
 
void wstring_towlower(std::wstring& str)
{
    for (auto& c : str)
    {
        c = towlower(c);
    }
}