#include <iostream>
#include <ostream>
#include <fstream>
#include <iterator>
#include <string>
#include <vector>
#include <map>
#include <algorithm>

static const wchar_t* WORD_DELIMITERS = L" \t\n\r!;:?()[]{}«»„…\".,";
                                                   // Инициализация вектора нескалярным инициализатором
static const std::vector< std::wstring > NONWORDS = { L"-", L"—", L"–", L"*"};

namespace std
{
    template<typename K, typename V>
    std::wostream &operator<<(std::wostream &o, const std::pair<K, V> &e)
    {
        o << L"[" << e.first << L"]=>" << e.second;
        return o;
    }

    template<typename T>
    std::wostream &operator<<(std::wostream &out, const std::vector<T> &v)
    {
        if (!v.empty())
        {
            out << '[';
            std::copy(v.cbegin(), v.cend(), std::ostream_iterator<T,wchar_t>(out, L",\n"));
            out << L"]\n";
        }
        return out;
    }

    template<typename K, typename V>
    std::wostream &operator<<(std::wostream &out, const std::map<K,V> &m)
    {
        if (!m.empty())
        {
            out << '{';
            std::copy(m.cbegin(), m.cend(), std::ostream_iterator< typename std::map<K,V>::value_type, wchar_t >(out, L",\n"));
            out << L"}\n";
        }
        return out;
    }
}

std::wstring tolower( const std::wstring &s )
{
    std::wstring r;
    std::transform( s.cbegin(), s.cend(), std::back_inserter(r),
      [] (const wchar_t &ch)  // а вот ЛЯМБДА! (безымянная функция оформленная в виде выражения)
      {
          return std::use_facet< std::ctype< wchar_t > >( std::locale("ru_RU.UTF-8") ).tolower( ch );
      }
    );
    return r;
}

template <typename K, typename V>
void printMap( std::wostream &out, const std::wstring &name, const std::map<K,V> &m )
{
    out << name << L".size() = " << m.size();
    out << L"\n";
    out << m << L"\n";
};

template <typename K, typename V>
void printMapSortedByValue( std::wostream &out, const std::wstring &name, const std::map< K, V > &m )
{
    std::vector< std::pair< K, V > > v(m.cbegin(), m.cend());
    std::sort( v.begin(), v.end(),
               // тоже лямбда
               [](const std::pair<K, V>& l, const std::pair<K,V>& r)
               { return l.second > r.second; } );

    out << name << L".size() = " << m.size();
    out << L"\n";
    out << v;
};

std::vector<std::wstring> splitLine(const std::wstring& input, const std::wstring& delimiters)
{
    std::vector<std::wstring> split;
    std::wstring::size_type next_start = 0;
    for( unsigned b = 0; next_start != std::wstring::npos && b < input.size(); b = next_start )
    {
        auto e = input.find_first_of( delimiters, b );
        if( e != std::wstring::npos )
        {
            const std::wstring &w = input.substr(b, e - b);
            split.push_back( w );
            next_start = input.find_first_not_of( delimiters, e );
        }
        else
        {
            const std::wstring &w = input.substr(b);
            split.push_back( w );
            next_start = std::wstring::npos;
        }
    }
    return split;
}

int main( int argc, char* argv[] )
{
    std::setlocale(LC_ALL, NULL);
    // this is needed in GCC for imbue( utf8 ) to work on wcout.
    std::ios_base::sync_with_stdio(false);
    std::locale utf8("ru_RU.UTF-8");

    if( argc < 2 )
    {
        std::wcout << L"Usage: wd filename" << std::endl;
        return -1;
    }

    std::wcout.imbue( utf8 );

    std::wifstream in( argv[1] );
    in.imbue( utf8 );

    std::wofstream output( std::string(argv[1]) + ".wd");
    output.imbue( utf8 );

    std::map< std::wstring, unsigned > wd;

    while( in.good() )
    {
        std::wstring ln;
        std::getline( in, ln, wchar_t('\n') );
        if( ln.empty() )
            continue;

        auto line_words = splitLine( ln, WORD_DELIMITERS );
        for( auto w : line_words )
        {
            if( w.empty() )
                continue;

            w = tolower( w );
            if( std::find( NONWORDS.cbegin(), NONWORDS.cend(), w ) == NONWORDS.cend() )
                ++(wd[w]);
        }
    }

    printMap( std::wcout, L"wd", wd );
    printMap( output, L"wd", wd );
    printMapSortedByValue( output, L"wd", wd );
    return 0;
}

Я бы не вводил отдельно функцию tolower()