Разделение слов на слоги.

#include <iostream>
#include <clocale>
#include <stdlib.h>
#include <string>
#include <stdio.h>
//------------------------------------------------------------------
typedef std::string TString;
//------------------------------------------------------------------
//Функция, которая проверяет, принадлежит ли буква множеству
//гласных букв
bool IsVowel(char letter){
  char l = tolower(letter);
  TString a = "аоэиуыеёюя";
  for(size_t i=0;i<a.length();i++)
    if(a[i] == l) return true;
  return false;
}
//------------------------------------------------------------------
//Функция, которая проверяет, принадлежит ли буква множеству
//согласных букв
bool IsConsonant(char letter){
  char l = tolower(letter);
  TString a = "бвгдйжзклмнпрстфхцчшщ";
  for(size_t i=0;i<a.length();i++)
    if(a[i] == l) return true;
  return false;
}
//------------------------------------------------------------------
//Функция, которая проверяет, принадлежит ли буква множеству
//русских букв
bool IsLetter(char letter){
  char l = tolower(letter);
  TString a = "абвгдеёжзийклмнопрстуфхцчшщыъьэюя";
  for(size_t i=0;i<a.length();i++)
    if(a[i] == l) return true;
  return false;
}
//------------------------------------------------------------------
//Функция, которая проверяет наличие гласной буквы в строке
bool ContainVowel(TString str){
  for(size_t k=0;k<str.length();k++)
    if(IsVowel(str[k])) return true;
  return false;
}
//------------------------------------------------------------------
//Функция, которая выделяет из текста слово
TString GetWord(TString str){
  TString word;
  size_t i=0 , n = str.length();

  while (!IsLetter(str[i]) && i < n)
    i++;

  while (IsLetter(str[i]) && i < n){
    word += str[i];
    i++;
  }

  return word;
}
//------------------------------------------------------------------
//Функция, которая разбивает слово на слоги
TString SplitWord(TString str){
  TString split, syll;
  size_t len = str.length(), i = 0;
  //Идем вдоль слова
  while(i < len){
    //Проверка 1-го критерия
    if(IsConsonant(str[i]) && IsVowel(str[i+1]) && IsVowel(str[i+2])){
      if(i+3 < len){
        syll = str.substr(i,2);
        split.append(syll);
        split += '-';
        i += 2;
      }
    } else
    //Проверка 1-го критерия не прошла, проверяем 2-ой
    if(IsVowel(str[i]) && IsConsonant(str[i+1]) && IsConsonant(str[i+2])){
      if(i+3 < len)
        if(ContainVowel(str.substr(i+3))){
          syll = str.substr(i,2);
          split.append(syll);
          split += '-';
          i += 2;
        }
    } else
    //Проверка 2-го критерия не прошла, проверяем 3-й
    {
      size_t m = i;
     
      while(!IsVowel(str[m]) && m < len) m++;
      m++;
      syll = str.substr(i,m-i);
      if(m < len)
        if(ContainVowel(str.substr(m))){
          split.append(syll);
          split += '-';
          i = m;
        }
    }
    split += str[i];
    i++;
    //Дополнительное условие для некоторых случаев
    if(IsVowel(str[i-1]) && i < len)
      if(ContainVowel(str.substr(i)))
        split += '-';
  }
  return split;
}
//------------------------------------------------------------------
TString Processing(TString str){
  size_t start, end  = str.length();
  TString text, word;
    //а-на-нас
  for(size_t i=0;i<end;i++){
    start = i;
    //Получение очередного слова
    word = GetWord(str.substr(start,end));
    i += word.length();
    //Разбивка на слоги
    text.append(SplitWord(word));
    //Конец разбивки на слоги
    //Вставка знаков препинания
    while(!IsLetter(str[i]) && i < end){
      text += str[i];
      i++;
    }
    i--;
  }
  return text;
}
//------------------------------------------------------------------
int main(int argc, char *argv[]) {
  setlocale(LC_ALL,"Rus");
  TString text = "Пожалуйста помогите написать следующую программу для курсача!";
  std::cout << text << std::endl;
  std::cout << Processing(text) << std::endl;
  system("pause");
  return 0;
}
//------------------------------------------------------------------

//Для подключения и использования стандартной библиотеки ввода-вывода
#include <iostream>
//Подключение библиотеки строковых функций:
//memset(), strcpy(), strlen(), strncat()
//их описание легко найти в сети
#include <string.h>
#include "stdlib.h"
//Для вывода русских символов на консоль (см. setlocale(LC_ALL,"Rus"))
#include <clocale>
//Делаем глобальным пространство имен стандартных шаблонов
using namespace std;
//Глобальные константы для длин вспомогательных текстовых буферов
#define SUBL 512
#define BIGL 4096
//------------------------------------------------------------------
//Сам алгоритм разбиения, а также его элементы реализованы
//с помощью функций. Благодаря такому подходу код будет компактным,
//ясным и хорошо структурирован. Кроме того, функция main не будет
//загромождена текстом программы.
//------------------------------------------------------------------
//Сначала реализуем несколько вспомогательных функций, которые
//помогут сделать наглядным наш алгоритм
//------------------------------------------------------------------
//Функция IsVowel возвращает 1 (истина), если проверяемый символ letter
//является гласной буквой русского алфавита и 0 (ложь) в противном
//случае
////////////////////////////////////////////////////////////////////
bool IsVowel(char letter){
  char l = tolower(letter);//приводим символ к нижнему регистру А->а
  char a[] = "аоэиуыеёюя";//10
  for(int i=0;i<strlen(a);i++)//по очереди проверяем
    if(a[i] == l) return true;//является ли символ l одним из a[i]
  return false;
}
//------------------------------------------------------------------
//Функция IsConsonant возвращает 1 (истина), если проверяемый символ letter
//является согласной буквой русского алфавита и 0 (ложь) в противном
//случае
////////////////////////////////////////////////////////////////////
bool IsConsonant(char letter){
  char l = tolower(letter);//приводим символ к нижнему регистру А->а
  char a[] = "бвгдйжзклмнпрстфхцчшщ";//21
  for(int i=0;i<strlen(a);i++)
    if(a[i] == l) return true;
  return false;
}
//------------------------------------------------------------------
//Функция IsLetter возвращает 1 (истина), если проверяемый символ letter
//является буквой русского алфавита и 0 (ложь) в противном
//случае
////////////////////////////////////////////////////////////////////
bool IsLetter(char letter){
  char l = tolower(letter);//приводим символ к нижнему регистру А->а
  char a[] = "абвгдеёжзийклмнопрстуфхцчшщыъьэюя";//33
  for(int i=0;i<strlen(a);i++)
    if(a[i] == l) return true;
  return false;
}
//------------------------------------------------------------------
//Функция ContainVowel возвращает 1 (истина), если в строке str
//есть гласная буква русского алфавита и 0 (ложь) в противном
//случае
////////////////////////////////////////////////////////////////////
bool ContainVowel(char *str){
  for(int k=0;k<strlen(str);k++)
    if(IsVowel(str[k])) return true;
  return false;
}
//------------------------------------------------------------------
//Функция InsertDash вставляет тире в позицию pos строки str
////////////////////////////////////////////////////////////////////
void InsertDash(char *str,int pos){
  int n = strlen(str);
  for(int i=n+1;i>pos;i--)
    str[i] = str[i-1];
  str[pos] = '-';
}
//------------------------------------------------------------------
//Функция GetWord выделяет из текста str первое
//встреченное в ней слово
////////////////////////////////////////////////////////////////////
char* GetWord(char* str,char* buf){
  memset(buf,'\0',SUBL);//заполняем буфер нулями
  int i=0, j=0, n = strlen(str);
  //пропускаем не буквы
  while (!IsLetter(str[i]) && i < n)
    i++;
  //а буквы не пропускаем
  while (IsLetter(str[i]) && i < n){
    buf[j] = str[i];
    i++; j++;
  }
  return buf;
}
//------------------------------------------------------------------
//Функция SubString возвращает фрагмент строки начиная с символа
//в позиции pos и длиной len
////////////////////////////////////////////////////////////////////
char* SubString(char* str, char* buf, int pos, int len){
  int n = strlen(str), i, j = 0, a = len + pos;
  memset(buf,'\0',SUBL);//заполняем буфер нулями

  if(len == 0 || a > n) a = n;//контроль выхода за границы

  for(i=pos;i<a;i++,j++)//копируем элементы в подстроку
    buf[j] = str[i];

  return buf;
}
//------------------------------------------------------------------
//Функция SplitWord - главная функция, которая разбивает слово str
//на слоги и возвращает группу слогов разделенных тире
////////////////////////////////////////////////////////////////////
char* SplitWord(char* str,char* buf){
  char sub[SUBL];
  memset(sub,'\0',SUBL);//заполняем буфер нулями
  strcpy (buf,str);
  int pos = 0, len = strlen(str), i = 1;
  while(i < len){
    if(i+2 < len){
      //проверка первого условия из задания
      // сг-гx (x - хотя бы одна буква)
      if(IsConsonant(str[i-1]) && IsVowel(str[i]) &&
                                                  IsVowel(str[i+1]) ){
        InsertDash(buf,i+1+pos);
        pos++;
      } else
      //проверка второго условия из задания
      // гс-сy (y - имеется хотя бы одна гласная)
      if(IsVowel(str[i-1]) && IsConsonant(str[i]) && IsConsonant(str[i+1]) &&
                                      ContainVowel(SubString(str,sub,i+2,0))){
        InsertDash(buf,i+1+pos);
        pos++;
      } else
      //проверка третьего условия из задания
      // xг-y  (y - имеется хотя бы одна гласная)
      if(IsLetter(str[i-1]) && IsVowel(str[i]) &&
         ContainVowel(SubString(str,sub,i+1,2))){
        InsertDash(buf,i+1+pos);
        pos++;
      }
      //обработка случая, когда два первых символа гласные
      if(i == 1 && IsVowel(str[i-1])  &&
         ContainVowel(SubString(str,sub,i,2))){
        InsertDash(buf,i);
        pos++;
      }
    }
    i++;
  }
  return buf;
}
//------------------------------------------------------------------
//Функция Processing принимает строку str, которая может состоять
//из нескольких слов и возвращает строку с разбитыми на слоги словами
//Эту простую функцию мы будем вызывать в main
////////////////////////////////////////////////////////////////////
char* Processing(char* str,char* buf){
  int start, end  = strlen(str), j=0, i=0;
  char buf1[SUBL], buf2[SUBL], buf3[SUBL], *word = NULL;
  memset(buf,'\0',BIGL);//заполняем буфер нулями
  while(i < end){
    //Вставка знаков препинания
    //если не буква, значит знак препинания
    while(!IsLetter(str[i]) && i < end){
      buf[j] = str[i];
      i++; j++;
    }
    start = i;
    //Получение очередного слова
    word = GetWord(SubString(str,buf1,start,end),buf3);
    i += strlen(word);
    //Разбивка на слоги
    //копируем разбитое слово в буфер
    strcpy (buf1,SplitWord(word,buf2));
    //вставляем слово из буфера в результирующую строку
    strncat(buf,buf1,strlen(buf1));
    j += strlen(buf1);
    //Конец разбивки на слоги
  }
  return buf;
}
//------------------------------------------------------------------
int main(int argc, char *argv[]) {
  //Эта команда позволяет выводить русские символы на консоль
  //забей в гугл "вывод русских символов на консоль C++"
  setlocale(LC_ALL,"Rus");
  char buf[BIGL];//Объявляем вспомогательный текстовый буфер
  char text[] =
  "Пример текста слова которого надо разбить на слоги.";
  cout << text << endl;
  cout << Processing(text,buf) << endl;
  char text1[] =
  "Гарри Поттер Маша Троттер Карл Поппер дезоксирибонуклеиновая.";
  cout << text1 << endl;
  cout << Processing(text1,buf) << endl;
  //system("cls") - использовать незачем
  system("pause");
  return 0;
}
//------------------------------------------------------------------

int main(int argc, char *argv[]) {
  setlocale(LC_ALL,"Rus");
  char buf[BIGL];//Объявляем вспомогательный текстовый буфер
  char text[BIGL];
  cout << "Введите текст : " << endl;
  cin >> text;
  cout << Processing(text,buf) << endl;
  system("pause");
  return 0;
}