동적할당 해제 관련 질문

#pragma once
#include <list>
#include <stack>
 
typedef enum
{
	LEFT_PARENTHESIS = '(', RIGHT_PARENTHESIS = ')',
	PLUS = '+', MINUS = '-', MULTIPLY = '*', DIVIDE = '/',
	SPACE = ' ', OPERAND
} SYMBOL;
 
int IsNumber(char Cipher);
unsigned int GetNextToken(char* Expression, char* Token, int* type);
int IsPrior(char Operator1, char Operator2);
void GetPostfix(char* InfixExpression, char* PostfixExpression);
double Calculate(char* PostfixExpression);

#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, char* Token, int* TYPE)
{
	unsigned int i = 0;
 
	for (i = 0; 0 != Expression[i]; i++)
	{
		Token[i] = Expression[i];
 
		if (IsNumber(Expression[i]) == 1)
		{
			*TYPE = OPERAND;
 
			if (IsNumber(Expression[i + 1]) != 1)
				break;
		}
		else
		{
			*TYPE = Expression[i];
			break;
		}
	}
 
	Token[++i] = '\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(char* InfixExpression, char* PostfixExpression)
{
	stack<char*, list<char*>> Stack;
 
	char Data1[32];
	char Token[32];
	int Type = -1;
	unsigned int Position = 0;
	unsigned int Length = strlen(InfixExpression);
 
 	while (Position < Length)
	{
		Position += GetNextToken(&InfixExpression[Position], Token, &Type);
 
		if (Type == OPERAND)
		{
  			strcat(PostfixExpression, Token);
			strcat(PostfixExpression, " ");
		}
		else if (Type == RIGHT_PARENTHESIS)
		{
			while (!Stack.empty())
			{
				char* Data = Stack.top();
				Stack.pop();
 
				if (Data[0] == LEFT_PARENTHESIS)
				{
					break;
				}
				else
				{
					strcat(PostfixExpression, Data);
				}
			}
		}
		else
		{
			while (!Stack.empty() && !IsPrior(Stack.top()[0], Token[0]))
			{
				char* Data = Stack.top();
				Stack.pop();
 
				if (Data[0] != LEFT_PARENTHESIS)
					strcat(PostfixExpression, Data);
 
			}
 
			char* Data1 = new char[];      // 이부분
			strcpy(Data1, Token);
			Stack.push(Data1);
 
		}
	}
 
	while (!Stack.empty())
	{
		char* Data = Stack.top();
		Stack.pop();
 
		if (Data[0] != LEFT_PARENTHESIS)
			strcat(PostfixExpression, Data);
	}
             // 이부분2
}