SOS SOS!!! Ошибки с динамической памятью...

//---------------------------------------------------------------------------
 
#include <vcl.h>
#pragma hdrstop
#include "Analizator.h"
#include <tchar.h>
                                  // НАВЕРНО НАДО Q ВЕЗДЕ ДЕЛАТЬ, А ТО ТЕРЯЕТСЯ ЧАСТЬ ДАННЫХ
 
//---------------------------------------------------------------------------
#pragma argsused
#define pi  3.14159265
 
/*############################################################################*/
#include <math.h>
#include <string.h>
#include <iostream.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <SysUtils.hpp>
 
bool ErrorCode;
int RAZMER = 10;
void Error(int X)
{ if (X == 110) cout << "ОШИБКА В СИНТАКСИСЕ ВЫРАЖЕНИЯ!!!\n";
  else if (X == 111) cout << "Ошибка в расстановке операторов\n";
  else if (X == 112) cout << "Выражени содержит неопределенные лексемы\n";
  else if (X == 113) cout << "Ошибка синтаксиса - несбалансированы скобки\n";
  else if (X == 115) cout << "Ошибка синтаксиса - после скобок должен стоять оператор\n";
  else if (X == 201) cout << "Выход за пределы области допустимых значений\n";
  }
int divide (char *string, char **mass)           // разбиение на лексемы
// если возвращает положительное значение - значит кол-во ЛЕКСЕМ
// если возвращает отричательное значение - значит это код ошиби
{
int i = 0;         // счетчик символов
int H = 0;         // cxtnxbr S
int X = 0;         // счетчик занесенных в таблице лексем
char S[15] = "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";     // переменная будет содержать очередную Лексему
 strset(S,'\0');
char ch[1] = "";   // переменная для хранения операторов и простых Лексем
 
 
while (string[i] != '\0')           // пока строка не пуста
    { if (strchr(" _",string[i]) != NULL) i++;     //если пробел - пропускаем
      else
      if (strchr("0123456789",string[i]) == NULL)      //если символ не цифра
      {
        if ((string[i] == '.')                         // если символ точка (разделитель)
        && (strchr("0123456789",string[i-1]) != NULL))  // и предыдущий символ цифра
        { ch[0] = string[i];
        S[H] = ch[0]; H++;  i++;     }           // присоединяем к лексеме
        else if (strchr("()*/+-^piesncotglqrPIESNCOTGLQR",string[i]) == NULL) {
               // если символ не входит в список всех возможно применяемых
               Error(110); return 0;
             }
             else
             // если это символ, используемый в константах
             if (strchr("piesncotglqrPIESNCOTGLQR",string[i]) != NULL) {
                   ch[0] = string[i];   // копируем его в лексему
                   S[H] = ch[0]; H++;
                   i++;
             }
             else     // если это минус
             if (string[i] =='-') {
                  if ((strchr("0123456789)",string[i-1]) == NULL)||(i == 0)) {  // если это УНАРНЫЙ минус
                  // если передыдущий символ не цифра и не закрывающая скобка
                       ch[0] = string[i];   // копируем минус в лексему
                       S[H] = ch[0]; H++;
                       i++;
             }
             else     // если просто минус - добавляем его в таблицу
             {
              if (strlen(S) != 0)       // если лексема не пуста
             {for (int i = 0; i < H; i++)mass[X][i] = S[i];        // копируем ее в таблицу
              X++; H = 0;
             for (int i = 0; i < 14; i++) S[i] = '\0';             // очищаем Лексему
             ch[0] = string[i];
             mass[X][0] = ch[0];
             i++; X++;}                                            // наращиваем счетчики
 
             else
             {ch[0] = string[i];
             mass[X][0] = ch[0];
             i++; X++;}
             } }
             else {
             if (strlen(S) != 0)       // если лексема не пуста
             {for (int i = 0; i < H; i++)
                               mass[X][i] = S[i];        // копируем ее в таблицу
              X++; H = 0;
             for (int i = 0; i < 14; i++) S[i] = '\0';             // очищаем Лексему
             ch[0] = string[i];
             mass[X][0] = ch[0];
             i++; X++;}                                            // наращиваем счетчики
             else
             {ch[0] = string[i];                          // ???? ГДЕ ТО СДЕСЬ С МИНУСОМ ЗАЕДАЕТ
             mass[X][0] = ch[0];
             i++; X++;}
             }
      }
      else {     // если символ цифра
        ch[0] = string[i];
        S[H++] = ch[0];    // копируем цифру в нее
        i++;             // наращиваем счетчик символов
      }
    }
 
     // эти две стоки проверяют, не осталась ли последняя лексема незанесенной в таблицу
     if (strlen(S) != 0)                                   // если лексема не пуста
     {for (int i = 0; i < H; i++) mass[X][i] = S[i];  X++; }    // копируем ее в таблицу
return X;
}
 
// возвращает новый размер таблици или -1 (если ошибка)
 
// ОШИБКА ПРИ РАБОТЕ С ПАМЯТЬЮ!!! ЗАТИРАЮТСЯ ПЕРВЫЕ СИМВОЛЫ МАССИЫВ MASS МНОГИЕ КОВЕРКАЮТСЯ!!!
 
 
int brackets(char **mass, int X /*кол-во записей в таблице*/)
// функция проверяет корректность расстановки скобок, убирает лишние скобки
{ int i = 0;
int balance = 0;
for (i = 0; i < X; i++)
{
if (mass[i][0] == '(')
{balance++;
if (strchr("sctlSCTL",mass[i-1][0]) == NULL)   // если перед скобкой не зарезервированная операция
 if ((strchr("0123456789",mass[i+1][0]) != NULL)&&(mass[i+2][0] == ')')) {
 // если в скобках стоит лишь одно число
mass[i][0] = '#';
mass[i+2][0] = '#';
balance--;
 }
 else if ((mass[i+1][0] == '-')      // если в скобках отрицательное число
          && (strchr("0123456789",mass[i+1][1]) != NULL)
          && (mass[i+2][0] == ')')) {
               mass[i][0] = '#';
               mass[i+2][0] = '#';
               balance--;}
 else if ((mass[i+1][0] == 'p')       // если в скобках число пи
           && (mass[i+1][1] == 'i')
           && (mass[i+1][2] == '\0')
           && (mass[i+2][0] == ')')) {
               mass[i][0] = '#';
               mass[i+2][0] = '#';
               balance--;}
 else if ((mass[i+1][0] == 'e')       // если в скобках экспанента
          && (mass[i+1][1] == '\0')
          && (mass[i+2][0] == ')')) {
               mass[i][0] = '#';
               mass[i+2][0] = '#';
               balance--;}
 else if ((strchr("*/+-^",mass[i+1][0]) != NULL)
          &&(mass[i+2][0] == ')'))  // если в скобках операнд
          { Error(114); return -1;}
 else if (mass[i+1][0] == ')') {   // если в скобках пусто
               mass[i][0] = '#';
               mass[i+1][0] = '#';
               balance--;}
}
else if (mass[i][0] == ')')
{balance--;
if (i != X-1)
 if ((strchr("*/+-^)",mass[i+1][0]) == NULL)) {
      Error(115); return -1; }
}
}
if (balance != 0) {Error(113); return -1;}
 
int K = 0; // счетчик перемещения записи
for (i = 0; i < X; i++) {
  if (mass[i][0] == '#') K++;  // если запись была затерта наращиваем счетчик смещения
  else
  strcpy(mass[i-K],mass[i]);  // смещаем элементы уничтожая затертые
}
for (i = X-K; i < X; i++) mass[i] = NULL;
 
return (X-K);
 
}
/*############################################################################*/
 
int Symbols(char **mass, int X /*кол-во записей в таблице*/)
{  int i = 0;
 for (i = 0; i < X; i++) {
    if (strchr("/*+-^",mass[i][0]) != NULL)   // если это знак операции
 {    if (strchr("/*+-^",mass[i-1][0]) != NULL)  return 111;
     else if (mass[i-1][0] == '(') return 111;
    }
}      // тут надо еще варианты с неправильной постановкой знаков просмотреть
 
   return 0;
}
 
int Constant (char **mass, int X)
{     int i;
for (i = 0; i < X; i++) {
     if (strchr("sctlSCTL",mass[i][0]) != NULL) {    // если ВОЗМОЖНО зарезервированная операция
      if (AnsiStrIComp(mass[i],"sin") == 0) continue;
       if (AnsiStrIComp(mass[i],"cos") == 0) continue;
        if (AnsiStrIComp(mass[i],"tan") == 0) continue;
         if (AnsiStrIComp(mass[i],"ctg") == 0) continue;
          if (AnsiStrIComp(mass[i],"ln") == 0)  continue;
           if (AnsiStrIComp(mass[i],"log") == 0) continue;
            if (AnsiStrIComp(mass[i],"sqrt") == 0) continue;
             if (AnsiStrIComp(mass[i],"Pi") == 0)
             {strcpy(mass[i],"3.145926536"); continue; }
              if (AnsiStrIComp(mass[i],"E") == 0)
             {strcpy(mass[i],"2.718281828"); continue; }
 
 
     return (112);
     } else i++;
}
return 0;
}
 
//###########################################//
 
double calc1(char **mass, int X)         // НАДо ПРОТЕСТИРОВАТЬ!!!
{ int i = 0; int k = 0;
    double A;
    double B;
    double Result;
    int Left = 0;
    int Right = 0;
 
if (X == 1) {return  atof(mass[0]); // если в скобках одно число
}
    // проход ПЕРВЫЙ - проверяем на возведение в степень
// ненужные лексемы замещаем '#'
for (i = 0; i < X; i++) {
    if (mass[i][0] == '^') { // если нашли возведение в степень
      Left = i;  Right = i;
      while ((strchr("1234567890",mass[Left][0]) == 0)) Left--;
      while ((strchr("1234567890",mass[Right][0]) == 0)) Right++;
      B = atof(mass[Right]);
      Result = pow (A,B);
   int RAZMER1;
   int dec, sign;
    char *Str = (char*)malloc(RAZMER*sizeof(char));
    char *StrBuf = (char*)malloc(RAZMER*sizeof(char));
   if (RAZMER > 15) {RAZMER1 = 15;} else RAZMER1 = RAZMER;
      Str = ecvt(Result,RAZMER,&dec,&sign);
  int K = 0;
      strset(mass[Left],'\0');
      if (sign == 1)
      {mass[Left][K] = '-'; K++;}
        int S;
      for (S = 0; S < dec; S++, K++) mass[Left][K] = Str[S];
      mass[Left][K++] = '.';
       for (int j = S; j < RAZMER1; j++, K++) mass[Left][K] = Str[j];
          strset(mass[i],'\0');
          strset(mass[Right],'\0');
          mass[i][0] = mass[Right][0] = '#';
    }}
// проход ВТОРОЙ - ДЕЛЕНИЕ И УМНОЖЕНИЕ
for (i = 0; i < X; i++) {
    if ((mass[i][0] == '*')||(mass[i][0] == '/')) { // если нашли умножение
          Left = i;  Right = i;
//    while ((strchr("1234567890",mass[Left][0]) == NULL)||(strchr("1234567890.",mass[Left][1]) == NULL)) Left--;
//    while ((strchr("1234567890",mass[Right][0]) == NULL)||(strchr("1234567890.",mass[Right][1]) == NULL)) Right++;
      while ((strchr("1234567890",mass[Left][0]) == NULL)) Left--;
      while ((strchr("1234567890",mass[Right][0]) == NULL)) Right++;
      A = atof(mass[Left]);
      B = atof(mass[Right]);
      if (mass[i][0] == '*') Result = A*B;
      else Result = A/B;
   int RAZMER1;
   int dec, sign;
    char *Str = (char*)malloc(RAZMER*sizeof(char));
    char *StrBuf = (char*)malloc(RAZMER*sizeof(char));
   if (RAZMER > 15) {RAZMER1 = 15;} else RAZMER1 = RAZMER;
      Str = ecvt(Result,RAZMER,&dec,&sign);
  int K = 0;
      strset(mass[Left],'\0');
      if (sign == 1)
      {mass[Left][K] = '-'; K++;}
        int S;
      for (S = 0; S < dec; S++, K++) mass[Left][K] = Str[S];
      mass[Left][K++] = '.';
       for (int j = S; j < RAZMER1; j++, K++) mass[Left][K] = Str[j];
          strset(mass[i],'\0');
          strset(mass[Right],'\0');
          mass[i][0] = mass[Right][0] = '#';
}}
 
// проход ТРЕТИЙ - СЛОЖЕНИЕ И ВЫЧИТАНИЕ
for (i = 0; i < X; i++) {
    if (mass[i][0] == '+') { // если нашли сложение
          Left = i;  Right = i;
//    while ((strchr("1234567890",mass[Left][0]) == 0)||(strchr("1234567890.",mass[Left][1]) == 0)) Left--;
//    while ((strchr("1234567890",mass[Right][0]) == 0)||(strchr("1234567890.",mass[Right][1]) == 0)) Right++;
      while ((strchr("1234567890",mass[Left][0]) == 0)) Left--;
      while ((strchr("1234567890",mass[Right][0]) == 0)) Right++;
      A = atof(mass[Left]);
      B = atof(mass[Right]);
   Result = A+B;
   int RAZMER1;
   int dec, sign;
    char *Str = (char*)malloc(RAZMER*sizeof(char));
    char *StrBuf = (char*)malloc(RAZMER*sizeof(char));
   if (RAZMER > 15) {RAZMER1 = 15;} else RAZMER1 = RAZMER;
      Str = ecvt(Result,RAZMER,&dec,&sign);
  int K = 0;
      strset(mass[Left],'\0');
      if (sign == 1)
      {mass[Left][K] = '-'; K++;}
        int S;
      for (S = 0; S < dec; S++, K++) mass[Left][K] = Str[S];
      mass[Left][K++] = '.';
       for (int j = S; j < RAZMER1; j++, K++) mass[Left][K] = Str[j];
          strset(mass[i],'\0');
          strset(mass[Right],'\0');
          mass[i][0] = mass[Right][0] = '#';
} else if (mass[i][0] == '-' && (strchr("1234567890",mass[i][1]) != 0))
// если это вычитание
{
          Left = i;  Right = i;
      while ((strchr("1234567890",mass[Left][0]) == 0)) Left--;
      while ((strchr("1234567890",mass[Right][0]) == 0)) Right++;
      A = atof(mass[Left]);
      B = atof(mass[Right]);
   Result = A-B;
   int RAZMER1;
   int dec, sign;
    char *Str = (char*)malloc(RAZMER*sizeof(char));
    char *StrBuf = (char*)malloc(RAZMER*sizeof(char));
   if (RAZMER > 15) {RAZMER1 = 15;} else RAZMER1 = RAZMER;
      Str = ecvt(Result,RAZMER,&dec,&sign);
  int K = 0;
      strset(mass[Left],'\0');
      if (sign == 1)
      {mass[Left][K] = '-'; K++;}
        int S;
      for (S = 0; S < dec; S++, K++) mass[Left][K] = Str[S];
      mass[Left][K++] = '.';
       for (int j = S; j < RAZMER1; j++, K++) mass[Left][K] = Str[j];
          strset(mass[i],'\0');
          strset(mass[Right],'\0');
          mass[i][0] = mass[Right][0] = '#';
}
 
}
//в конце работы функции в таблице остается лишь одна запись, содержащая решение
for (i = 0; i < X; i++) if (strstr(mass[i],".") != NULL) break;
// по идее должно работать как определение чиcла
 
return atof(mass[i]);
 
 
}
//###########################################//
double CalcOperation(char *mass, double ZN)       // ПОЧЕМУ ТО ПЕРЕМЕННУЮ MASS коверкает
{  int i = 0;
      if (AnsiStrIComp(mass,"sin") == 0) return sin(ZN*pi/180);   // не считает синус
       if (AnsiStrIComp(mass,"cos") == 0) return cos(ZN*pi/180);
        if (AnsiStrIComp(mass,"tan") == 0) return tan(ZN*pi/180);
  //         if (AnsiStrIComp(mass,"ctg") == 0) return ctn(ZN); что такое котангенс???
          if (AnsiStrIComp(mass,"ln") == 0)
           {if (ZN >= 0) return log(ZN); else Error(201);  }
     //    if (AnsiStrIComp(mass,"log") == 0) return log(ZN);   // ЭТО КАК РЕАЛИЗОВАТЬ???
            if (AnsiStrIComp(mass,"sqrt") == 0)
            {if (ZN >= 0) return sqrt(ZN); else Error(201);  }
}
 
char *DoubleToStr (double NUM)       // че то нолик не вырисовывает...
{
    char *Str = (char*)malloc(RAZMER*sizeof(char));
    char *StrBuf = (char*)malloc(RAZMER*sizeof(char));
    int dec, sign;
   int RAZMER1;
   if (RAZMER > 15) {RAZMER1 = 15;} else RAZMER1 = RAZMER;
      Str = ecvt(NUM,RAZMER,&dec,&sign);
  int K = 0;
      strset(StrBuf,'\0');
      if (sign == 1)
      {Str[K] = '-'; K++;}
        int S;
      for (S = 0; S < dec; S++, K++) StrBuf[K] = Str[S];
 /*!!!!*/     StrBuf[K++] = ','; // StrBuf[K++] = '.';
       for (int j = S; j < RAZMER1; j++, K++)
       StrBuf[K] = Str[j];
       return StrBuf;
       }
 
double calculation (char **mass, int X /*кол-во записей в таблице*/)
{ int i; int k = 0; int SCOB = 0; int length = 0;//  char **P;
     bool SCTL = false;
   char **Q = new char*[X];
    for (int i = 0; i < X; i++)
    {Q[i] = new char[RAZMER];
    strcpy(Q[i],mass[i]);}
 
    for (i = X-1; i != -1; i--) { // идем с конца пока не найдем самую последнюю открывающую скобку
   if (Q[i][0] == '(')
   { length = 0;
   if (strchr("sctlSCTL",Q[i-1][0]) != NULL)  // если это SIN COS TG CTG LN LOG SQRT
            SCTL = true;
       SCOB++;   // нашли скобку - нарастили счетчик
         k = i;  int Pos = i;
        while (Q[k][0] != ')')       // length - это длина массива без #
        if (Q[k][0] == '#') {k++; }
        else {k++; length++;}
        length--;
    char **P = new char*[length];
    for (int i = 0; i < length; i++) P[i] = new char[RAZMER];
//      char *StringBufer  = (char*)malloc(RAZMER*sizeof(char));
//      strcpy(StringBufer,mass[3]);
//          P = (char**)malloc(length*sizeof(char));
//          for (int i = 0; i < length; i++) P[i] = (char*)malloc(RAZMER*sizeof(char));
             int GTR = 0;
    for (int i = 0; i < length; i++)
     if (Q[Pos+1][0] != '#') {
        strcpy(P[i],Q[Pos+1]); strset(Q[Pos+1],'\0');
        Q[Pos+1][0] = '#'; Pos++;
         } else
         {
/*!!!!*/         if (Pos == length) break;     // тут может не Length a length+1
                  else Pos++; i--; }
          Pos -=GTR;
       //-----------СЧИТАЕМ------------//
          double REZ1 = calc1(P,length);
       // ПРОВЕРЯЕМ НА ЗАРЕЗЕРВИРОВАННЫЕ ОПЕРАТОРЫ //
               strset(Q[Pos+1],'\0');
               Q[Pos+1][0] = '#';
         if (SCTL == true)
         {  SCTL = false;
            strset(Q[Pos-length],'\0');
            Q[Pos-length][0] = '#';
            double REZ2 = CalcOperation(Q[Pos-length-1],REZ1);
 
  char *S = new char[100];
  S = DoubleToStr(REZ2);
  if (REZ2 >= 1) strcpy(Q[Pos-length-1],DoubleToStr(REZ2));
  else { strcpy(Q[Pos-length-1],"0");
         strcat(Q[Pos-length-1],DoubleToStr(REZ2));}
         } else  strcpy(Q[Pos-length],DoubleToStr(REZ1));
   }
}
// ВОТ ТЕПЕРЬ НУЖНО СЧИТАТЬ ВСЕ ЧТО ОСТАЛОСЬ В ТАБЛИЦЕ В P[]
// И ПОСЧИТАТЬ... ВЕРНУТЬ ПОЛУЧИВШЕЕСЯ ЗНАЧЕНИЕ!!!!
// НУЖНО УЧИТЫВАТЬ, ЧТО В ТАБЛИЦЕ МОГУТ ОСТАТЬСЯ СИМВОЛЫ '#' и ')'
int G = 0;
for (int i = 0; i < X; i++) {
    if (Q[i][0] != '#') { if (G != i) {strcpy(Q[G],Q[i]);
                          strset(Q[i],'\0');
                          Q[i][0] = '#';} G++;}
    }  X = G;
if (X > 1) {double REZ3 = calc1(Q,X);  return REZ3;}
else
return StrToFloat(Q[0]);      //че то не хочет переводить
}
 
 
double calc(char p[])
{    int length = strlen(p);           // длина строки входного параметра
 
int X = 0;                             // счетчик занесенных в таблице лексем
double Number = 0;
 
/*как динамически создать двумерный массив????*/
//char *mass = new char[length];   // создаем первый массив строк, который будет содержать лексемы
//  mass[1] = new char [15];
    char *string = new char[length];       // создаем дополнительную строку
 
 
char **mass = (char**)malloc(length*sizeof(char));
for (int i = 0; i < length; i++) {    // обнуляем массив для избежания ошибок
    mass[i] = (char*)malloc(RAZMER*sizeof(char)); }
 
//for (int i = 0; i < length; i++) {    // обнуляем массив для избежания ошибок
//  for (int j = 0; j < 15; j++) {
//  mass[i][j] = '\0'; }}
 
    strcpy(string,p);                      // и помещаем в нее выражение
    X = divide (string, mass);  // перегоняем строку в таблицу лексем
    if (X == -1) return NULL;
 
//**************************************************************//
//    этап считывания строки и разбиения на лексемы ЗАВЕРШEН    //
//**************************************************************//
    int Y = brackets(mass, X);
    if (Y == -1) ErrorCode = true;
    int G = Y;
    Y = Symbols(mass,G);   // проверили на расстановку символов
    if (Y != 0) Error(Y);
 
    Y = Constant(mass,G);
    if (Y != 0) Error(Y);
 
    Number = calculation (mass,G);
 
//  for (int i = 0; i < X; i++) {        // вывод лексем
//      puts(mass[i]); }
    cout <<"OTBET = "<< Number<<endl;
 
return 0;
}
/*############################################################################*/
 
int _tmain(int argc, _TCHAR* argv[])
{  char *P = (char*)malloc(256*sizeof(char));
ErrorCode = false;
//char P[] = "-35+(5^2+sqrt(16)+1)*(4+(-3))/sin(10+1)";
//char S[] = "-3.123";
int dec,sign;
/*while (1)
{  double NUM; int KOL;
cout <<"Chislo = ";
cin>>NUM;
cout <<"\nCol = ";
cin >> KOL;
cout<<endl;
char *SSS = ecvt(NUM,KOL,&dec,&sign);
int i = 0;
while (SSS[i] != '\0') {cout <<SSS[i]; i++;}
cout <<"\n dec = "<<dec<<"\nsign = "<<sign<<endl;
}     */
loopONE:
cout << "VVEDITE TEXT: ";
gets(P);
double X = calc(P);
if (ErrorCode == true) {
                    cout << "Error!!! Error!!! Error!!!";
}
goto loopONE;
getch();
    return 0;
}
//---------------------------------------------------------------------------