Вывести только те слова сообщения, которые встречаются в нем более n раз

/////////////////////////////////////////////////////////////////////////////////////////
//Дано осмысленное текствовое сообщение (т.е. алфавитно-цифровая информация, разделенная
//пробелами и знаками препинания, в конце которого ставится точка.
//
//Вывести только те слова сообщения, которые встречаются в нем более n раз. 
/////////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <iostream>
#include <locale>
#include <set>
#include <sstream>
#include <string>
#include <windows.h> 
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::string           T_str;
typedef std::set<T_str>       T_words_set;
typedef std::multiset<T_str>  T_words_multiset;
/////////////////////////////////////////////////////////////////////////////////////////
T_str  from_DOS(const T_str&  DOS_string)
{   
    char*  p_buf = new char[DOS_string.length() + 1];
    OemToCharA(DOS_string.c_str(), p_buf);
    T_str  res(p_buf);
    delete[] p_buf;
    return res;
}
/////////////////////////////////////////////////////////////////////////////////////////
void  remove_puncts(T_str&  s)
{
    struct  T_is_rus_punct
    {
        bool  operator() (char  c)
        {
            return  std::ispunct(c, std::locale(""));
        }
    };
    std::replace_if(s.begin(), s.end(), T_is_rus_punct(), ' ');
}
/////////////////////////////////////////////////////////////////////////////////////////
T_words_set  get_words_with_count_greater
    (
        int           n, 
        const T_str&  s
    )
{   
    std::istringstream  ssin(s);
    T_words_multiset  words_multiset(
                                        (std::istream_iterator<T_str>(ssin)),
                                        (std::istream_iterator<T_str>())
                                    );
 
    struct T_count_is_less_eq_in
    {
        size_t                   n_;
        const T_words_multiset&  words_multiset_;    
        //-------------------------------------------------------------------------------
        T_count_is_less_eq_in
            (
                size_t                   n,
                const T_words_multiset&  words_multiset            
            )
            : n_               (n),
              words_multiset_  (words_multiset)
        {}
        //-------------------------------------------------------------------------------
        bool  operator() (T_words_multiset::value_type  words_multiset_elem)
        {
            return  words_multiset_.count(words_multiset_elem) <= n_;
        }
    };
 
    T_words_set  words_set_res;
 
    std::remove_copy_if(
                           words_multiset.begin(),
                           words_multiset.end(),
                           std::inserter(words_set_res, words_set_res.begin()),
                           T_count_is_less_eq_in(n, words_multiset)
                       );
 
    return  words_set_res;
}
/////////////////////////////////////////////////////////////////////////////////////////
int main()
{
    std::locale::global(std::locale(""));
    std::cout << "Введите предложение:"
              << std::endl;
    
    T_str  DOS_s;
    getline(std::cin, DOS_s);
    T_str  s = from_DOS(DOS_s);
    remove_puncts(s);
 
    int  n = 0;
    do
    {
        std::cout << "n >= 0: ";
        std::cin >> n;
    }while(n < 0);        
    
    T_words_set  words_set = get_words_with_count_greater(n, s); 
    if(words_set.empty())
    {
        std::cout << "В заданном предложении нет слов, встречающихся более "
                  << n
                  << " раз."
                  << std::endl;
    }
    else
    {
        std::cout << "В заданном предложении более "
                  << n
                  << " раз встречаются следующие слова:"
                  << std::endl;
 
        std::copy(words_set.begin(), words_set.end(), 
                  std::ostream_iterator<T_str>(std::cout, "\n"));    
    }
}

#include <iostream>
#include <locale>
#include <vector>
#include <string>
#include <sstream>
#include <iterator>
#include <algorithm>
#include <map>
 
int main()
{
    typedef std::ctype<char> StdFacet;
    typedef unsigned char uchar;
 
    //--------
 
    std::cout << "Input string: ";
    std::string line;
    std::getline(std::cin, line);    
 
    std::vector<StdFacet::mask> masks(StdFacet::table_size, StdFacet::mask());
 
    const std::string delim = "!?., ";
    for(std::string::const_iterator it = delim.begin(); it != delim.end(); ++it)
        masks[static_cast<uchar>(*it)] = StdFacet::space;
 
    std::istringstream iss(line);
    std::locale loc(iss.getloc(), new StdFacet(&masks[0]));
    iss.imbue(loc);
 
    std::map<std::string, int> m;
    std::string t;
    while(iss >> t) ++m[t];
 
    std::cout << "input n: ";
    int n;
    std::cin >> n;
 
    for(std::map<std::string, int>::iterator it = m.begin(); it != m.end(); ++it)
        if(it->second > n) std::cout << it->first << '\n';
 
    return 0;
}

#include <iostream>
#include <string>
 
//-------------
 
struct Item
{
    std::string word;
    int occurences;
    Item* next;
 
    Item(const std::string& s)
        : word(s), occurences(1), next(NULL)
    {
    }
};
 
//-------------
 
Item* add(Item* pointerTo1stItem, const std::string& str)
{
    if(pointerTo1stItem == NULL) return new Item(str);
 
    Item* last;
    for(Item* item = pointerTo1stItem; item != NULL; item = item->next)
    {
        if(item->word == str)
        {
            ++item->occurences;
            return pointerTo1stItem;
        }
 
        last = item;
    }
 
    last->next = new Item(str);
 
    return pointerTo1stItem;
}
 
//------------
 
void cleanUp(Item* item)
{
    Item* next;
    while(item != NULL)
    {
        next = item->next;
        delete item;
        item = next;
    }
}
 
//-------------
 
int main()
{
    std::cout << "input sentence: ";
    std::string s;
    std::getline(std::cin, s, '.');
    s+= '.';
 
    const std::string delim = "\n\t,.!? ";
 
    std::string::size_type first = 0;
    std::string::size_type last = 0;
 
    Item* item = NULL;
 
    while(s[last] != '.' && (first = s.find_first_not_of(delim, last)) != std::string::npos)
    {
        last = s.find_first_of(delim, first);
        item = add(item, s.substr(first, last - first));
    }
 
    std::cout << "input n: ";
    int n;
    std::cin >> n;
 
    for(Item* p = item; p != NULL; p = p->next)
        if(p->occurences > n) std::cout << p->word << '\n';
 
    cleanUp(item);
 
    return 0;
}