#include <iostream>
#include <memory>
#include <stack>
#include <vector>
#include <string>
#include <cstdint>

using namespace std;

// Внимание!
// Для простоты разбора будем использовать только числа из одной цифры,
// а также не будет скобок, пробелов и ненужных символов.
// При этом, будем считать, что выражение всегда корректно.

struct Node
{
	virtual int Evaluate() const = 0;
};

struct Value: public Node
{
	Value(char digit) : _value(digit - '0')
	{
	}

	int Evaluate() const override
	{
		return _value;
	}

private:
	const uint8_t _value;
};

struct Variable: public Node
{
	Variable(const int &x) : _x(x)
	{
	}

	int Evaluate() const override
	{
		return _x;
	}

private:
	const int &_x;
};

struct Op: public Node
{
	Op(char value) : precedence([value]
	{
		if (value == '*')
		{
			return 2;
		}
		else
		{
			return 1;
		}
	}()), _op(value)
	{
	}

	const uint8_t precedence;

	int Evaluate() const override
	{
		if (_op == '*')
		{
			return _left->Evaluate() * _right->Evaluate();
		}
		else if (_op == '+')
		{
			return _left->Evaluate() + _right->Evaluate();
		}
		else if (_op == '-')
		{
			return _left->Evaluate() - _right->Evaluate();
		}

		return 0;
	}

	void SetLeft(shared_ptr<Node> node)
	{
		_left = node;
	}
	void SetRight(shared_ptr<Node> node)
	{
		_right = node;
	}

private:
	const char _op;
	shared_ptr<const Node> _left, _right;
};

template<class Iterator>
shared_ptr<Node> Parse(Iterator token, Iterator end, const int &x)
{
	// Empty expression
	if (token == end)
	{
		return make_shared<Value>('0');
	}

	stack<shared_ptr<Node>> values;
	stack<shared_ptr<Op>> ops;

	auto PopOps = [&](int precedence)
	{
		while (!ops.empty() && ops.top()->precedence >= precedence)
		{
			auto value1 = values.top();
			values.pop();
			auto value2 = values.top();
			values.pop();
			auto op = ops.top();
			ops.pop();

			op->SetRight(value1);
			op->SetLeft(value2);

			values.push(op);
		}
	};

	while (token != end)
	{
		const auto &value = *token;
		if (value >= '0' && value <= '9')
		{
			values.push(make_shared<Value>(value));
		}
		else if (value == 'x')
		{
			values.push(make_shared<Variable>(x));
		}
		else if (value == '*')
		{
			PopOps(2);
			ops.push(make_shared<Op>(value));
		}
		else if (value == '+' || value == '-')
		{
			PopOps(1);
			ops.push(make_shared<Op>(value));
		}

		++token;
	}

	while (!ops.empty())
	{
		PopOps(0);
	}

	return values.top();
}

int main()
{
	string tokens;
	cout << "Enter expression: ";
	getline(cin, tokens);

	int x = 0;
	auto node = Parse(tokens.begin(), tokens.end(), x);

	cout << "Enter x: ";
	while (cin >> x)
	{
		cout << "Expression value: " << node->Evaluate() << endl;
		cout << "Enter x: ";
	}

	return 0;
}