C++, Visual Studio 2008; Определение частоты появления слов в тексте сортировкой..

//Составить частотный словарь слов заданного текста. Текст может вводится с клавиатуры или из файла. В качестве текста можно использовать текст программы. Определить слова, встречающиеся чаще всех и реже всех. Пользователь выбирает вариант варианты ввода текста:
//·         с клавиатуры,
//·         из файла, с указанием имени файла,
//·         текст данной программы.
//
//Производится сохранение самого часто и реже встречающегося слова в файл.
 
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
 
//подключаемые файлы
#include <ctype>
#include <fstream>
#include <windows>
#include <iomanip>
#include "stdafx.h"
#include <string.h>
#include <locale>
#include <stdio.h>
#include <iostream>
//подключение поля namespase
using namespace std;
////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////класс текст/////////////////////////////////////
//должен включать в себя: переменные слов str; длины текста, из которого формируются слова size;
//количества повторений слов k;; функции сортировки слов Sortword(сперва находится количество повторений
//каждого слова в тексте, описывается в переменной k, затем сортируются слова по количеству повторений -
//от максимального к минимальному); фукнцию вывода слов Show (выводится строка, в которой содержатся max-но и
//min-но встречающеися в тексте слова); конструктор Text (принимает текст, записанный в переменной ttext, 
//инициализирует str, size и k); деструктор./////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////
class Text
 {
     //объявления:
 public:
     //конструктор по умолчанию
 Text();
    //деструктор
 ~Text();
    //конструктор с передаваемым текствовым массивом в качестве параметра
 Text (char ttext);
    //функция вывода слов Show
 const char* Show(void);
    //функция сортировки слов
 void SortWord(void);
 private:
     //переменная слов
 char* str;
    //результирующа я строка
 char *stroka;
    //переменная длины текста
 int size;
    //переменная количества повторений слов
 int* k;
    //переменная количества слов
int Word;
 };
/////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////Конструктор с передаваемым текствовым массивом в качестве параметра///////////////////
//должен находить длину текста size, разбивать текст на слова str, инициализировать количество повторений
//каждого слова k/////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////
Text (auto char ttext)
{
    //инициализируем переменную для поиска пробелов в тексте 
    char ch = '0';
    //инициализируем переменную количества слов
    int Word=0;
    //находим длину текста
    int size = strlen(ttext);
    //заводим цикл, в котором:
    for (int i = 0 ; i < size ; i++)
    {
    //выводим указатель на первое вхождение пробела
    int m = char* strrchr(char ttext, char ch);
    //когда встречаем первый пробел в тексте
    while(m)
    {
 
    //создаём переменную слова str, счётчик количества слов str, массив повторений слов k//
 
    // вычисляем количество символов от начала текста до первого пробела 
    int с = m-i;
    // копируем эти символы из ttext в char
    char *strncpy (char *ttext, char *str, int c);
    //увеличиваем кол-во слов на 1
    Word++;
    //инициализируем массив повторений слов k
    k= new int[size+1];
    // каждое слово имеет значение количества повторений, равного единице 
    k[]=1;
    }}
}
////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////Деструктор класса//////////////////////////////////////////
//Должен чистить память от переменных слов str, длины текста size и количества повторений k
////////////////////////////////////////////////////////////////////////////////////////////////
Text::~Text()
{
    //очищаем память массива слов
    delete[] str;
    // очищаемпамть количества повторений слов
    delete[] k;
}
//////////////////////Функция сортировки слов (по возрастанию)////////////////////////////////////////////////
//функция должна использовать введённые слова str, длину текста size  и количество повторений k, производить 
//подсчёт количества повторений k для каждого слова str (ниже - как именно), сортировку слов str относительно
//количества повторений слов k от максимального значения в переменной k к минимальному//////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Text::SortWord(void)
{
     ////используем введённые слова
 
////операция нахождения количества повторений слов k
     //реализуем цикл для всех слов
    for (int i=0; i<Word-1; i++) 
        {
            //реализуем вложенный цикл, обходящий все слова, помимо текущего
            for (int j=1; j<Word; j++)
            {
                //условие:
                //если текущее слово совпадает с выбранным
                if (str[i]==str[j]) 
                    //увеличиваем значение количества повторений k для текущего слова str на единицу 
                    {k[i] = k[i] + 1;}
            }
    }
    ////нашли кол-во повторений k для кажлого слова str
 
 
    ////Сортируем слова по количеству повторений
 
    //обходим все слова в цикле
    for (int i = 0; i<Word; i++)
    {
        //инициализируем:
        //первоначальные значения, принимающие изнчально максимальные значения: 
        //в переменую максимальных значений количества повторений mkol заносим текущее значение k
        int maxkol=k[i];
        // инициализируем в переменной maxpos адреса максимально встречающегося слова str значение i
        int maxpos = i;
        //в вложенном цикле, обходящем все слова, кроме текущего,
        for (int j=i; j<Word; j++) 
        {
            //условие:
            //если текущее значение переменной max встречающегося кол-ва слова maxkol < выбранного
            //кол-ва повторений,
            if (maxkol < k[j])
            {
                //заводим буфер для текущего значения массива количества повторений
                int buffer1;
                buffer1 = k[i];
                //меняем значения k[i] и k[j]
                k[i]=k[j];
                k[j]=buffer1;
 
                //заводим переменную для текущего значения слова
                char buffer2;
                buffer2 = str[i];
                //меняем значения теущего и выбранного слова
                str[i] = str[j];
                str[j] = buffer2;
 
                //устанавливаем значения переменных максимального количества повторений maxkol
                //и его количество адрес на новое текущее значение
                maxkol=k[i];
                maxpos=i;
            }
    ////завершили сортировку слов
        }
}
 
}
 
/////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////Функция вывода слов Show///////////////////////////////////////////////
//функция должна принимать отсортированный относительно количества повторений k массив слов str,
//выделять в нём максимально и минимально встречающиеся слова, выводить в главную функцию
///////////////////////////////////////////////////////////////////////////////////////////////////
const char* Text::Show(void)
{   
        ////вывод на печать максимально и минимально встречающегося слова:
            //копируем переменные max и min встречающихся слов в сроку str 
        //объявляем и инициализируем переменную пробела
        char buf='0';
        //объявляем указатель на переменную
        char *buff = &buf;
        //копируем в переменную str переменную слова с индексом 0 (Максимально встречающееся слово)
        strcpy(stroka,str[0]);
        //копируем в переменную str переменную пробела
        strcpy(stroka, buff);
        // копируем в переменную str переменную слова с индексом Word (минимально встречающееся слово)
        strcpy(stroka, str[Word]);
 
        //ВЫВОД СТРОКИ
        return  stroka;
 
        ////также ещё дожно быть реализовано вывод количество повторений max иmin встречающихся слов
        //return k[0];
        //return k[Word];
        ////
 }
////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////главная функция программы//////////////////////////////////////////////////
//должен производиться ввод текста - с командной строки и из файла; создание объекта класса и
//передача ему текста в качестве параметра; реализованы функция сортировки слов и функция вывода слов;
//сохранение максимально и минимально встречающегося слова в отдельный файл/////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
int _tmain(int argc, _TCHAR* argv[])
{
    //поключение русского языка
    setlocale(LC_ALL, "Russian");
 
    // инициализиреем переменную выбора меню
    int vybor;
 
////////////////////////////////////////////////////////MENU///////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    cout << "<><><><><><><><>" << endl;
    cout << "<><><>MENU<><><>" << endl;
    cout << "<><><><><><><><>" << endl;
    cout << endl;
    cout << endl;
    cout << "1)Ввод текста с командной строки" << endl;
    cout << "2)Ввод текста из файла" << endl;
    cout << "3)Вывод слов на экран" << endl;
    cout << "4)Вывод текста в файл" << endl;
 
 
    cin>> vybor;
    while (true)
    {
        switch(vybor)
        {
            case 1:
                //инициализируем переменную для текста
                auto char*  ttext;
                // ввод текста
                cout<<"введите текст"<< endl;
                cin>> ttext;
 
                //выполнение программы:
                //объявление класса
                Text K;
                //сортировка слова
                K.SortWord();
                break;
 
            case 2:
            //ввод из файла:
            cout<< "cout fail's name:"<< endl;
            cin>>ttext;
            ifstream f(ttext, ios::in||ios::noncreate);
            if(!f)
            {cout<< "fail dont found"<<endl; return 1;}
            while(!eof.f)
            {getline f(ttext,200);
            close();}
    
            //выполнение программы:
            //объявление класса
            Text K;
            //сортировка слова
            K.SortWord();
            break;
 
        case 3:
 
            //вывод на экран
            std::cout<<K.Show()<<std::endl;
            break;
 
        }
 
        case 4:
            //сохранение в файл
                out<< "cout fail's name:"<< endl;
                cin>> text2;
                ifstream f(text2, ios::out||ios::noncreate)
                if (!f)
                    {cout<< "fail dont found"<< endl; return 1;}
                while (!eof.f)
                    {fputs (vyvod, 200);
                    close();}
        }
    ////закрыли меню
    
return 0;
}