С++

[programming]

Здравствуйте , в коде есть 1 ошибка , которая почему-то у меня не ловится отладчиком ,
если кто подскажет что не так , буду премного благодарен .

Cобственно код

// Tree_function.cpp: определяет точку входа для консольного приложения.
//

#include "stdafx.h"
#include "iostream"
#include "math.h"

using namespace std ;


const int n = 100 ; // мах. длина вводимой функции как строки 
const int m = 5 ; // размер массивов bin_set[] и un_set[]
char   bin_set[] = {'+','-','*','/','^'} ;// массив бинарных операций
char   un_set[] = {'s','c','t','l','a'} ; // массив унарных операций

// Сокращённые имена для унарных операций :

// sin(x) ~ s(x) 
// cos(x) ~ c(x) 
// tg(x) ~ t(x)
// ctg(x) ~ 1/t(x)
// abs(x) ~ a(x)
// ln(x) ~ l(x)
// log[a](b) = ln(b)/ln(a) ~ l(b)/l(a)
// -a ~ (0-1)*a

// Бинарные операции :
// +
// - 
// *
// /
// ^ 

int length = 0 ; // длина вводимой функции ;
bool error = false ; /* логическая переменная , которая следит за корректным вводом ;
                       устанавливается в true , если есть ошибка на синтаксическом или 
                       логическом уровне (деление на ноль,>0 подлогарифмическое выражение,
                       правильное расставление скобок , корректные символы в выражении */

class tree_function
{
private :
	
	struct node
	{
		char key[n] ; // key -строка(или 1 символ),являющийся операндом или оператором
		float value ; // поле для последующего вычисления значения функции
		node * left ;
		node * right ;
	} ;

	node * root ; // корень дерева
	node * q ;//вспомогательный узел 

char * function ; // вводимая функция в виде строки


int min_index ; // индекс операции с минимальным приоритетом
char type_operator ; // тип оператора ( унарный или бинарный ) 


void transform( )
{
	char * ch ;

	// -x ~ (0-1)*x
   
	for ( int i = 0 ; i < strlen(function) ; i ++)
	  {
	   char ch = function[i] ;                
	   if ( ch == '-' )
            if  ( ( i == 0 ) || (function[i-1] == '(') || ( function[i-1] == '[')  ) 
			{
				int n = strlen(function) ;
				char s[] = {"(0-1)*"} ;
			    int l = 0;
				
		
			for (int j = n ; j >= (i+1); j-- ) 
				function[j+strlen(s)-1] = function[j];

			for (int j = i ; j < i + strlen(s); j++ ) 
				function[j] = s[l++];
					
			}
	  }
	  
	    
	    // log[a](b) = ln(a)/ln(b) ~ l(a)/l(b) 
        while ( ( ch = strstr(function ,"log" )) != NULL )
		{
            int l1 = 0,l2 = 0 ;
			char a[50]  ; // строка - основание логарифма
			char b[50]  ;// строка - подлогарифмическое выражение     
			int count = 0 ;

			for ( int i = (ch - function + strlen("log")) ; i < strlen(function) ; i ++ )
			{
				if ( function[i] == '[' )
				{
					i++ ;
					while ( function[i] != ']' )
					{
					a[l1++] = function[i] ;
					a[l1] = '\0';
					i++ ;
					}
				}

				if ( function[i] == '(' ) 
				{
					i++ ;
					while ( ( function[i] != ')') || (count) )
					{
						if (function[i] == '(') count ++ ;
						if (function[i] == ')') count -- ;

					b[l2++] = function[i] ;
					b[l2] = '\0' ;
					i++ ;
					}
					break ;
				}
			}

			char  c[n];
			c[0] = '\0' ;

            strcat(c,"l(") ;
			strcat(c,b) ;

			strcat(c,")/l(") ;
			strcat(c,a) ;

			strcat(c,")") ;

			int l = 0;
			for (int j = ch - function ; j < (ch-function) + strlen(c) ; j ++ )
				function[j] = c[l++] ;
		
		}

	
	    //ctg(x) = 1/tg(x) ~ 1/t(x)
		while ( ( ch = strstr(function ,"ctg" )) != NULL )
		{

			char s[] = {"1/t"} ;
			int l = 0;

			for (int j = (ch - function) ; j <strlen("ctg"); j++ ) 
				function[j] = s[l++];
		}


        // sin(x) ~ s(x)
		while ( ( ch = strstr(function ,"sin" )) != NULL )
		{
			for (int j = (ch - function + 1) ; j <( strlen(function) - strlen("sin") + 2); j++ ) 
			{function[j] = function[j + strlen("sin") - 1 ];} 
		} 

		// cos(x) ~ c(x)
		while ( ( ch = strstr(function ,"cos" )) != NULL )
		{
			for (int j = (ch - function + 1) ; j <( strlen(function) - strlen("cos") + 2); j++ ) 
			{function[j] = function[j + strlen("cos") - 1 ];} 
		}
       
		// tg(x) ~ t(x)
		while ( ( ch = strstr(function ,"tg" )) != NULL )
		{
			for (int j = (ch - function + 1) ; j <( strlen(function) - strlen("tg") + 2); j++ ) 
			{function[j] = function[j + strlen("tg") - 1 ];} 
		}
		
		// ln(x) ~ l(x)
		while ( ( ch = strstr(function ,"ln" )) != NULL )
		{
			for (int j = (ch - function + 1) ; j <( strlen(function) - strlen("ln") + 2); j++ ) 
			{function[j] = function[j + strlen("ln") - 1 ];} 
		}

		// |x| = abs(x) ~ a(x)
		while ( ( ch = strstr(function ,"abs" )) != NULL )
		{
			for (int j = (ch - function + 1) ; j <( strlen(function) - strlen("abs") + 2); j++ ) 
			{function[j] = function[j + strlen("abs") - 1 ];} 
		}

		length = strlen(function) ;
	

}

void priority_op(int l , int r )
{
	char x ;//символ для считывания
	int count1 = 0 ; // кол-во открывающихся и закрывающихся скобок
	
	int priority = n  ; // приоритет операции 
	int min = n; // минимальный приоритет

	bool op = false; // принимает значение true если есть хотя бы 1 оператор 

	min_index = 0 ; // обнуление значений 
	type_operator = ' ' ;

	for (int i = l; i < r ; i++)
	{	
		x = function[i] ;

		if (( x == '(') || (x == ')'))
		{ 
			if (x == '(')
		    count1 ++ ;
		    else
			count1 -- ;
		}

		
		for ( int j = 0 ; j < m ;j++ )
		{

		if ( x ==  bin_set[j] )
		{
			if ( (x == '+' ) || (x == '-') )
			priority = 1 + 3*count1 ;	
			else
			priority = 2 + 3*count1 ;
			op = true ;  break ;
		}

		else if (x == un_set[j])
		{priority = 3 + 3*count1 ;
		op = true ; break ; }

		}

		if (priority < min)
		{
		min =  priority ;
		min_index = i ;
		type_operator = (!(priority % 3)) ? 'u' : 'b' ;
		}

		// в случае если нет ни 1-го оператора
		if (( op == false ) && ( i == r-1) )
			type_operator = 'n' ;

	}
}


void create_tree(node *& q , int l , int r  ) //создание дерева выражений (ключи пока являются символами)
		{    
            
			int k = 0;//счётчик для заполнения поля key в случае > 1 символа
				
			
			priority_op(l,r) ; // находим индекс операнда с минимальным приоритетом и его тип(бинарный или унарный) 
           
			int min  = min_index ;
			char type = type_operator ;
			
           
			node * p = new node ; // создаём новый узел
		
			q = p ; // связываем узел с предком
            
			
			if (( l == 0 ) && ( r == length ))  
				root = p;

		
			if  ( type != 'n' )
			{
			p->key[0] = function[min_index] ;
			p->key[1] = '\0' ;
			p->value = 0 ;
			}
			
			else
			
			for (int j = l ; j < r ; j++)
			{
				if  (  ( (function[j] >= '0') && (function[j]<= '9')) || (function[j]== '.') )
				{
				p->key[k++] = function[j] ;
				p->key[k] = '\0' ;
				}
            
			p->value = 0 ; 

			}
			
			
			p->left = NULL ;
			p->right = NULL ;

			

			if (type == 'b') // в случае бинарного оператора
			{
			create_tree(q->left , l , min) ;
			create_tree(q->right , min+1 ,r);
			}
			else if (type== 'u') // в случае унарного оператора
				create_tree(q->right ,min_index + 1,r);
			else
				return ;
			
}

void preorder(node * p)//Прямой обход дерева
		{
		    if (p)
			{
				cout << p->key <<"  "  ;
				preorder(p->left);
				preorder(p->right);
			}
			else
				return ;				
		}

void count_tree(node * p)//Обратный обход дерева
		{
		    if (p)
			{
				count_tree(p->left);
				count_tree(p->right);
				
			if  ( strlen(p->key) == 1 )
				{ 

				if ( (p->key[0]) >= '0' && (p->key[0] <='9') )
				p->value = p->key[0] - 48 ;

				else if ( (p->key[0] == '+') ||(p->key[0] == '-')||(p->key[0] == '*')||
					               (p->key[0] == '/') || (p->key[0] == '^')  )
				{
					if (p->key[0] == '+')
						p->value = (p->left->value) + (p->right->value) ;
					
					else if (p->key[0] == '-')
						p->value = (p->left->value) - (p->right->value) ;
					
					else if (p->key[0] == '*')
						p->value = (p->left->value) * (p->right->value) ;
					
					else if (p->key[0] == '/')
					{
						if (p->right->value)
						p->value = (p->left->value) / (p->right->value) ;
						else
							error = true ;
					}
					
					else if (p->key[0] == '^')
					{
						if ( (p->left->value < 0) && ( (int(p->right->value) - p->right->value ) != 0 ) )
						error = true ;
						else
						p->value = pow((p->left->value) , (p->right->value) ) ; // исключение
					
					}
					//удаление
					delete []p->left ;
					delete []p->right;
					p->left = NULL ;
					p->right = NULL ;
				}
				else
				{
					if ( p->key[0] == 's' ) // sin(x)
						p->value = sin(p->right->value) ;

					else if ( p->key[0] == 'c' ) // cos(x)
						p->value = cos(p->right->value) ;

					else if ( p->key[0] == 't' ) // tg(x)
						p->value = tan(p->right->value) ;

					else if ( p->key[0] == 'l' ) // ln(x)	
					{
						if ((p->right->value) > 0 )
						p->value = log(p->right->value) ;
						else
						error = true ;
					}
				
					else if ( p->key[0] == 'a' ) // abs(x)
						p->value = abs(p->right->value) ;

					
					delete []p->left ;
					delete []p->right;
					p->left = NULL ;
					p->right = NULL ;

				}
				
				}
			else
				{
					int k1 = 0 , k2 = 0 ;

					for (int j = strlen(p->key)- 1 ; j >= 0 ; j--)
					{
						k1 = pow(float(10),k2) ;
						
						if (p->key[j] != '.')
						{
							p->value = p->value  + k1 * ( (p->key[j]) - 48) ;
							k2++ ;
						}
						
						else
						{
						p->value = p->value / k1 ;
						k2 = 0 ;
						}

					}
				}
				
			}
			else
				return ;				
		}


public :
	
	tree_function(char * function) // конструктор c параметром
	{
	    (char *) this->function = new char[strlen(function)] ;
		strcpy (this->function ,function) ;
		
		
	
		root = NULL ;
		q = NULL ;
		min_index = 0 ;

		type_operator = ' ' ;
        
	}

	void control_input () // контроль ввода
{
	int c = 0 ; // кол-во (  и  ) скобок
	
	
	
	for (int i = 0 ; i < length ; i++)
	{
		if (function[i] == ' ')
		{
			for (int j = i ; j < length ; j++)
			{
				function[j] = function[j+1] ;
			}
		}
	}
	
	length = strlen(function);

	
	
	for ( int j = 0 ; j < length ; j ++ )
	{
		
		//sin(x)
		if ( function[j] == 's' )
		{   
		if ( j < length - strlen("sin") )
		{
		  if ((function[j+1] != 'i') || (function[j+2] != 'n') || (function[j+3] != '('))  
		  {error = true ; break ;}
		  else
			  j += strlen("sin") - 1 ;
		}	
		else
		{error = true ; break ;}
		}
       
	    //cos(x) и ctg(x)
		else if ( function[j] == 'c' )
		{   
		if ( j < length - strlen("cos") )
		{
		  if ( (  (function[j+1] == 'o') && (function[j+2] == 's') && (function[j+3] == '(')   )  ||
               (  (function[j+1] == 't') && (function[j+2] == 'g') && (function[j+3] == '(')   )   )
             j += strlen("cos") - 1 ;
		  else
		  {error = true ; break ;}
		}	
		else
		{error = true ; break ;}
		}
		
		//tg(x)
		else if ( function[j] == 't' )
		{   
		if ( j < length - strlen("tg") )
		{
		  if ((function[j+1] != 'g') || (function[j+2] != '(') )  
		  { error = true ; break ;}
		  else
			  j += strlen("tg") - 1 ;
		}	
		else
		{error = true ; break ;}
		}
		
		//ln(x)  и log[a](x)
		else if ( function[j] == 'l' )
		{   
		if ( j < length - strlen("ln") )
		{
		  if ( ( (function[j+1] != 'n')  && (function[j+1] != 'o') ) || 
			 (  (function[j+2] != '(') && (function[j+3] != '[')  )  ) 
		  {error = true ; break ;}
		  
		  else if ( function[j+1] == 'n')
			  j += strlen("ln") - 1 ;
		 
		  else 
		  {
			  if (function[j+2] != 'g' )
			  {error = true ; break ;}
			  else
			  j += strlen("log")-1 ;
		  }			  
		}	
		else
		 {error = true ; break ;}
		}

		
		//abs(x)
		else if ( function[j] == 'a' )
		{   
		if ( j < length - strlen("abs") )
		{
		  if ((function[j+1] != 'b') || (function[j+2] != 's') || (function[j+3] != '(') )  
		  {error = true ; break ;}
		  else
			  j += strlen("abs")  - 1;
		}	
		else
		 {error = true ; break ;}
		}
       
		//  ) 
		  else if (function[j] == ')')
		{
			if ( j != length - 1 )
			{
			if ( (( function[j+1] != '+')  && (function[j+1] != '-') && ( function[j+1] != '*')
			&&( function[j+1] != '/')&&( function[j+1] != '^')&&(function[j+1] != ')')) || ( j == 0) )
			{error = true ; break ;}
			}
		}
		
         // ( 
		 else if (function[j] == '(')
		{
			if ( j == length - 1 ) 
			{error = true ; break ;}
			
			else if (( function[j+1] == '+') || (function[j+1] == '*') || ( function[j+1] == '/')||
				     ( function[j+1] == '^') ||( function[j+1] == '.') || (function[j+1] == ')')  )
			{error = true ; break ;}
		}

		   // [
		 else if (function[j] == '[')
		{
			if (( j == length - 1 )||(!j) ) 
			{error = true ; break ;}
			
			else if (( function[j+1] == '+') || (function[j+1] == '*') || ( function[j+1] == '/')||
				     ( function[j+1] == '^') || (function[j+1] == '.') || ( function[j+1] == ')')  )
			{error = true ; break ;}
		}

		   // ]
		 else if (function[j] == ']')
		{
			if (( j == length - 1 )||(!j) ) 
			{error = true ; break ;}
			
			else if ( function[j+1] != '(' )
			{error = true ; break ;}
		}

		
		// возможные символы после символа бинарной операции :
		else if (( function[j] == '+')  || (function[j] == '-') || ( function[j] == '*')||
			     ( function[j] == '/')  || (function[j] == '^') )
		{
           if   (( function[j+1] == '+')  || (function[j+1] == '-') || ( function[j+1] == '*')||
			     ( function[j+1] == '/')  || (function[j+1] == '^') || ( function[j+1] == ')')||
				 ( function[j+1] == ']')  || ( function[j+1] == '.')  || (!j && (function[j] != '-')) || (j==length-1) )
		   {error = true ; break ;}
		}

	    // число
		else if ((function[j] >= '0') && (function[j] <= '9') )
		{
			if  ( ( function[j+1] != '+')  && (function[j+1] != '-') && ( function[j+1] != '*')&&
			      ( function[j+1] != '/')  && (function[j+1] != '^') && ( function[j+1] != ')')&&
				  ( function[j+1] != '.')  && ( (function[j+1]<'0')  ||  (function[j+1] > '9'))&& 
				  ( function[j+1] != ']') &&(j != length-1)  )
            {error = true ; break ;}

		}
		 
		 
		 // .
		else if ( function[j] == '.')
		{
			if ( (!j) || (j==length-1) )
			{error = true ; break ; }
			else
			{ if ( ( function[j+1] < '0' ) || ( function[j+1] > '9' ) )
			{error = true ; break ; }
			}
		}



		else if ( (( function[j] < '0' ) || (function[j] > '9')) && ( function[j] != '.') &&
			      ( function[j] != '+')  && (function[j] != '-') && ( function[j] != '*') &&
				  ( function[j] != '/')&&( function[j] != '^'))
		{
			{error = true ;break ;}
		}



		if ( ( function[j] == '(' )  || ( function[j] == ')' ) )
		{
			if ( function[j] == '(' )
				c ++ ;
			else
				c -- ;
		}

		 if ( j == length - 1 )
		 if (c) error = true  ;

	}
	
}

 

void make_tree()
{   
	
	transform() ;

	create_tree(q,0,length) ;

	

} 

void show_tree()
{
	count_tree(root) ;


	if (error == false)
	    cout<< root->value << endl ;
	else
		cout<< "Error" << endl ;

}
} ;


int _tmain(int argc, _TCHAR* argv[])
{

    char * f ;//вводимая функция 
	f = new char[n] ;
	cout << "F(x) = " ;
	
	f = gets(f) ;//ввод строки
	length = strlen(f) ;
	

	tree_function A(f)  ;
	A.control_input() ;
	
	if (error == false) 
	
	{
	A.make_tree() ;
	A.show_tree() ;}
	
	else
		cout << "Error" <<endl;

	return 0;
}

В общем программа работает , даже всё верно считает , но
есть тип примеров , когда программа попусту виснет .
Например если ввести действия с 2-мя отрицательными числами
f() = -2*(-2)

После ввода данного примера всё виснет . Пытался отладчиком
поймать ошибку , но он её не находит и выводит 4 (собственно что и должно быть)
Скорее всего ошибка в строчке node * p = new node (процедура Create_tree ) , т.к.
если написать до этой строчки что-то типа cout << "1" то 1 на экране появится(кстати от раза
к разу их то 1 то 4 ) , если же после , то нет .
Но что неправильного в этой строчке мне непонятно .
Заранее спасибо .