Работа с файлами и строками (MSVC++)

#include <stdio.h>
#include <string.h>

// Будем считать, что в тексте нет строк длинее, чем значение buffersize
#define buffersize 1024
// Также условимся, что словарный запас автора текста лишь немногим больше,
// чем у Эллочки Щукиной (см. "12 стульев")
#define maxwords   1024
// И, также как Винни-Пуха, слишком длинные слова нашу программу тоже будут
// только расстраивать
#define wordlength 128

#pragma argsused
int main(int argc, char* argv[])
{
    char    input_line[buffersize];       // Строка из текстового файла
    char    clear_line[buffersize];       // Та же строка, но "причёсанная",
                                          // без знаков препинания и двойных побелов
    char    words[maxwords][wordlength];  // Сюда запоминаем слова
    int     word_rating[maxwords];        // Сюда -- рейтинги (повторяемость слов)
    size_t  inv_char_pos;                 // Служебная переменная для поиска знаков препинания
    char    current_word[wordlength];     // Текущее слово
    char   *doublespace;                  // Служебная -- для поиска двойных пробелов
    char   *space_pos;                    // Служебная -- для разделения строки по словам
    char   *invalid_chars = "`~!@#$%^&*()_+\\|[]{};:\'\",.<>/?"; // Инвалидные символы
    size_t  words_len;                    // Длина слова
    int     word_count = 0;               // Сколько найдено слов
    int     i;                            // Понятно -- счётчик цикла. Не люблю писать "for(int i=..."
    bool    word_found;                   // Служебное -- данное слово найдено среди запомненных
    int     idx_max;                      // Индекс в массиве words слова с максимальной длиной
    FILE   *input_file;                   // см. stdio.h

    if((input_file = fopen("readme.txt", "rt")) != NULL)
    {
        while(!feof(input_file))
        {
            fgets(input_line, buffersize - 1, input_file);
            words_len  = strlen(input_line);

            // Давим \r и \n в конце строки
            while(input_line[words_len - 1] == '\r' || input_line[words_len - 1] == '\n')
                input_line[--words_len] = '\0';

            // Заменяем инвалидные символы пробелами
            strcpy(clear_line, input_line);
            while((inv_char_pos = strcspn(clear_line, invalid_chars)) < words_len)
                clear_line[inv_char_pos] = ' ';

            // Давим двойные пробелы
            doublespace = clear_line;
            while((doublespace = strstr(doublespace, "  ")) != NULL)
                strcpy(doublespace, doublespace + 1);

            // Выделяем отдельные слова
            while((words_len = strlen(clear_line)) > 0)
            {
                for(i = 0; clear_line != '\0' && clear_line != ' '; i++)
                    current_word = clear_line;
                if(clear_line == '\0'/*i == 0*/)
                    break;
                current_word = '\0';
                strcpy(clear_line, clear_line + i + 1);

                // Ищем полученное слово среди уже запомненных
                for(word_found = false, i = 0; i < word_count; i++)
                    if(strcmp(words, current_word) == 0)
                    {
                        // Если нашли, увеличиваем ему рейтинг
                        word_rating++;
                        word_found = true;
                        break;
                    }
                // Не нашли -- запоминаем и даём рейтинг = 1
                if(!word_found)
                {
                    strcpy(words[word_count], current_word);
                    ++word_rating[word_count++];
                }
            } // <<< while((words_len = strlen(clear_line)) > 0)
        } // <<< while(!feof(input_file))
        fclose(input_file);
    } // <<< if((InputFile = fopen("readme.txt", "rt")) != NULL)

    for(i = 0, idx_max = 0; i < word_count; i++)
        // Ищем слово длиннее первого...
        if( (strlen(words) > strlen(words[idx_max]))
            ||
        // ... или такой же длины, но с бОльшим рейтингом
            ((strlen(words) == strlen(words[idx_max]) && word_rating >= word_rating[idx_max]))
        )
                idx_max = i;
    // Всё! Печатаем.
    printf("%s|%d\n", words[idx_max], word_rating[idx_max]);

    return 0;
}

#include <string>
#include <vector>
#include <iterator>
#include <iostream>
#include <fstream>
#include <algorithm>
#include <functional>

/*
Консольное приложение, должно считывать текст из файла и определить сколько раз в нём попадалось самое длинное слово.
Заранее благодарю за помощь!
*/

template <typename T, template <typename> class Cmp>
struct comparer : public std::binary_function<T, T, bool>
{
    bool operator()(const T& s1, const T& s2) const
    { return Cmp<typename T::size_type>()(s1.size(), s2.size()); }
};

template <typename T>
struct match_length : public std::unary_function<T, bool>
{
    match_length(typename T::size_type len) : length_(len) {}
    bool operator()(const T& s) const
    { return s.size() == length_; }
    typename const T::size_type length_;
};


int main()
{
    typedef std::vector<std::string> V;
    V v;

    std::ifstream ifs("in.txt");
    std::copy(std::istream_iterator<V::value_type>(ifs), std::istream_iterator<V::value_type>(), std::back_inserter(v));

    std::cout <<
        std::count_if(
            v.begin(), v.end(),
                match_length<V::value_type>(
                    std::min_element(
                        v.begin(), v.end(),
                        comparer<std::string, std::greater>())->size())) <<
    std::endl;



    return (0);
}

#include <iostream>
#include <fstream>
#include <string>
#include <map>

using namespace std;

int main()
{
    const char FILE_NAME[] = "test.txt";
// формируем файл, чтобы прямо отсюда было понятно верен ли результат
    ofstream out(FILE_NAME);
    if(out)
        out << "test test ggg test testtest... testtest; m test \r\n test, gg test. \r fffff testtest \n";
    out.close();

// сам код
    ifstream in(FILE_NAME);
    map<size_t, size_t> counter;

    while (in)
    {
        string str;
        in >> str;
        // удаляем знаки препинания по краям слов
        while(str.size() && ispunct(str[0]))
            str.erase(str.begin());
        while(str.size() && ispunct(str[str.size() - 1]))
            str.erase(str.end() - 1);
        if(str.size())
            counter[str.size()]++;
    }
    map<size_t, size_t>::iterator p = counter.end();

    if(counter.size())
        cout << (--p)->second << endl;
    return 0;
}