Infix to Prefix

[tit0n]

if I take this expression -> (1+((2+3)∗(4∗5)))
it converts to this -> +**54+321

Anyone know a solution just based off my function here? I can post my infix to postfix if needed.

string Expression::inToPre(string myExpression){
// **********MUST BE FULLY PARENTHESIZED**********
    myExpression = inToPost(myExpression); //convert infix to postfix, then convert postfix to prefix
    int count, length;
    length = myExpression.length();


   string prefix = "";
   for(count = length - 1; count >= 0; count--)
{
       prefix += myExpression[count];

   }

return prefix;
}
}

[Mantorr22]

Not really fancy but it works at least for the most parts.

#include <iostream>
#include <string>
#include <stack>
#include <algorithm>
#include <sstream>

int prec(char input);

using namespace std;

int main()
{
	std::string final_string;
	std::string input_string;
	std::stack <char> expression_stack;

	// "(1 + ((2 + 3) * (4 * 5)))"
	cout << "Please enter an expression (For example, a + b - c)" << endl;
	cout << "Enter an expression : "; getline(cin, input_string);
	cout << "The prefix expression : ";
	{
		std::stringstream cout;

		int i = 0;
		while(i < input_string.size())
		{
			char input = input_string[i];

			if((input >= '0' && input <= '9') || (input >= 'a' && input <= 'z') || (input >= 'A' && input <= 'Z'))
			{
				cout << input << ' ';		
			}
			else if(input == '(')
			{
				expression_stack.push(input);		
			}
			else if(input == ')')
			{
				while(!expression_stack.empty() && expression_stack.top() != '(')
				{
					cout << expression_stack.top() << ' ';
					expression_stack.pop();
				}

				if(!expression_stack.empty()) expression_stack.pop();
				else
				{
					cout << endl;
					cerr << "Error : No matching '(' token" << endl; cin.get(); return 100;
				}
			}
			else if(input == '*' || input == '/' || input == '+' || input == '-')
			{
				if(expression_stack.empty() || prec(expression_stack.top()) < prec(input))
				{
					expression_stack.push(input);
				}
				else
				{
					while(!expression_stack.empty())
					{
						if(prec(expression_stack.top()) < prec(input)) break;
						
						cout << expression_stack.top() << ' ';
						expression_stack.pop();
					}

					expression_stack.push(input);
				}
			}
			else if(input_string[i] != ' ')
			{
				cout << endl;
				cerr << "Error : Invalid character or token : '" << input << "'" << endl; cin.get(); return 100;
			}	

			i++;
		}

		while(!expression_stack.empty())
		{
			cout << expression_stack.top() << ' ';
			expression_stack.pop();
		}

		final_string = cout.str();
		std::reverse(final_string.begin(), final_string.end());
	}

	cout << final_string;
	cout << endl;

	return 0;
}

// Returns a precedence value for a certain operator
// Lowest : (
// Normal : + -
// Highest : * /
int prec(char input)
{
	int precedence_input;
	if(input == '(') precedence_input = 0;
	else 
	{
		if(input == '+' || input == '-') precedence_input = 1;
		else
		{
			if(input == '*' || input == '/') precedence_input = 2;	
			else
			{
				cout << endl;
				cerr << "Error : Invalid input operator : " << input << endl; cin.get(); exit(100);
			}
		}
	}

	return precedence_input;
}

Please enter an expression (For example, a + b - c)
Enter an expression : (1 + ((2 + 3) * (4 * 5)))

The prefix expression :  + * * 5 4 + 3 2 1