메모리 해제

#include "헤더.h"
using namespace std;
 
char NUMBER[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.' };
 
int IsNumber(char Cipher)
{
	int ArrayLength = sizeof(NUMBER);
 
	for (int i = 0; i < ArrayLength; i++)
	{
		if (Cipher == NUMBER[i])
			return 1;
	}
 
	return 0;
}
 
unsigned int GetNextToken(char* Expression, string& Token, int& TYPE)
{
	unsigned int i = 0;
 
	for (i = 0; 0 != Expression[i]; i++)
	{
		string rep = Expression;
		Token.replace(i, 1, rep.substr(i,1));
 
		if (IsNumber(Expression[i]) == 1)
		{
			TYPE = OPERAND;
 
			if (IsNumber(Expression[i + 1]) != 1)
				break;
		}
		else
		{
			TYPE = Expression[i];
			break;
		}
	}
	Token.replace(++i, 100, "\0");
	return i;
}
 
int GetPriority(char Operator, int InStack)
{
	int Priority = -1;
 
	switch (Operator)
	{
	case LEFT_PARENTHESIS:
		if (InStack)
			Priority = 3;
		else
			Priority = 0;
		break;
	case MULTIPLY:
	case DIVIDE:
		Priority = 1;
		break;
	case PLUS:
	case MINUS:
		Priority = 2;
		break;
	}
 
	return Priority;
}
 
int IsPrior(char OperatorInStack, char OperatorInToken)
{
	return (GetPriority(OperatorInStack, 1) > GetPriority(OperatorInToken, 0));
}
 
void GetPostfix(string& InfixExpression, string& PostfixExpression)
{
	stack<string, list<string>> Stack;
 
	string Token;
	int Type = -1;
	unsigned int Position = 0;
	unsigned int Length = InfixExpression.length();
 
 	while (Position < Length)
	{
		Position += GetNextToken(&InfixExpression[Position], Token, Type);
 
		if (Type == OPERAND)
		{
  			PostfixExpression += Token;
			PostfixExpression += " ";
		}
		else if (Type == RIGHT_PARENTHESIS)
		{
			while (!Stack.empty())
			{
				string Data = Stack.top();
				Stack.pop();
 
				if (Data[0] == LEFT_PARENTHESIS)
				{
					break;
				}
				else
				{
					PostfixExpression += Data;
				}
			}
		}
		else
		{
			while (!Stack.empty() && !IsPrior(Stack.top()[0], Token[0]))
			{
				string Data = Stack.top();
				Stack.pop();
 
				if (Data[0] != LEFT_PARENTHESIS)
					PostfixExpression += Data;
 
			}
 
 
			Stack.push(Token);
		}
	}
 
	while (!Stack.empty())
	{
		string Data = Stack.top();
		Stack.pop();
 
		if (Data[0] != LEFT_PARENTHESIS)
			PostfixExpression += Data;
	}
 
}
 
double Calculate(string& PostfixExpression)
{
	double Result;
	string Token;
	int Type = -1;
	unsigned int Read = 0;
	unsigned int Length = PostfixExpression.length();
 
	stack<string, list<string>> Stack;
 
	while (Read < Length)
	{
		Read += GetNextToken(&PostfixExpression[Read], Token, Type);
		if (Type == SPACE)
			continue;
 
		if (Type == OPERAND)
		{
			string* Data1 = new string;
			*Data1 += Token;
			Stack.push(*Data1);
		}
		else
		{
			char ResultString[32];
			double Operator1, Operator2, TempResult;
 
			string Data = Stack.top();
			Stack.pop();
			Operator2 = atof(Data.c_str());
 
			string Data2 = Stack.top();
			Stack.pop();
			Operator1 = atof(Data2.c_str());
 
 
			switch (Type)
			{
			case PLUS:	TempResult = Operator1 + Operator2; break;
			case MINUS:	TempResult = Operator1 - Operator2; break;
			case MULTIPLY:	TempResult = Operator1 * Operator2; break;
			case DIVIDE:	TempResult = Operator1 / Operator2; break;
			}
 
			gcvt(TempResult, 10, ResultString);
 
			string* Data1 = new string;
			*Data1 += ResultString;
			Stack.push(*Data1);
		}
	}
 
	string Data = Stack.top();
	Stack.pop();
	Result = atof(Data.c_str());
 
	return Result;
}