Парсер арифметических выражений

std::map<char, std::size_t> prior;
prior.insert(std::make_pair("+", 1));
prior.insert(std::make_pair("-", 1));
prior.insert(std::make_pair("*", 2));
prior.insert(std::make_pair("/", 2));
prior.insert(std::make_pair("%", 2));
prior.insert(std::make_pair("^", 3));
prior.insert(std::make_pair("!", 3));
prior.insert(std::make_pair("(+)", 4));
prior.insert(std::make_pair("(-)", 4));

prior.insert(std::make_pair("sin", 5));

    Plus(Operation*root):Operation(1,root)
    {
        if(!left)
            //кидать исключения
            throw std::runtime_error("Ops..");
    }

#include <iostream>
#include <string>
#include <functional>
#include <unordered_map>
#include <cmath>
#include <cctype>
#include <algorithm>
#include <stack>
#include <memory>
 
// operations
// abstract class operation
 
class operation
{
public:
    virtual void exec(std::stack<double> &) const = 0;
    virtual ~operation() = default;
};
 
class op_add : public operation
{
public:
    void exec(std::stack<double> & stack) const override
    {
        const auto arg1 = stack.top();
        stack.pop();
        const auto arg2 = stack.top();
        stack.pop();
 
        stack.push(arg2 + arg1);
    }
};
 
class op_subtract : public operation
{
public:
    void exec(std::stack<double> & stack) const override
    {
        const auto arg1 = stack.top();
        stack.pop();
        const auto arg2 = stack.top();
        stack.pop();
 
        stack.push(arg2 - arg1);
    }
};
 
class op_multiply : public operation
{
public:
    void exec(std::stack<double> & stack) const override
    {
        const auto arg1 = stack.top();
        stack.pop();
        const auto arg2 = stack.top();
        stack.pop();
 
        stack.push(arg2 * arg1);
    }
};
 
class op_divide : public operation
{
public:
    void exec(std::stack<double> & stack) const override
    {
        const auto arg1 = stack.top();
        stack.pop();
        const auto arg2 = stack.top();
        stack.pop();
        if (arg1 == 0)
            throw std::invalid_argument("division by zero");
 
        stack.push(arg2 / arg1);
    }
};
 
class op_mod : public operation
{
public:
    void exec(std::stack<double> & stack) const override
    {
        const auto arg1 = stack.top();
        stack.pop();
        const auto arg2 = stack.top();
        stack.pop();
 
        stack.push(std::fmod(arg2, arg1));
    }
};
 
class op_pow : public operation
{
public:
    void exec(std::stack<double> & stack) const override
    {
        const auto arg1 = stack.top();
        stack.pop();
        const auto arg2 = stack.top();
        stack.pop();
 
        stack.push(std::pow(arg2, arg1));
    }
};
 
class op_fact : public operation
{
    double fact(double val) const
    {
        if (val == 0)
            return 1;
        return val * fact(val - 1);
    }
public:
    void exec(std::stack<double> & stack) const override
    {
        const auto arg = stack.top();
        stack.pop();
        if (arg < 0)
            throw std::invalid_argument("argument must be is greater zero");
 
        stack.push(fact(arg));
    }
};
 
class op_unary_plus : public operation
{
public:
    void exec(std::stack<double> & stack) const override
    {
        const auto arg = stack.top();
        stack.pop();
 
        stack.push(arg);
    }
};
 
class op_unary_minus : public operation
{
public:
    void exec(std::stack<double> & stack) const final override
    {
        const auto arg = stack.top();
        stack.pop();
 
        stack.push(-arg);
    }
};
 
// factory
 
class ops_factory
{
public:
    using object_uptr = std::unique_ptr<operation>;
    using creator_function = std::function<object_uptr(void)>;
 
private:
    std::unordered_map<char, creator_function> _creation_data;
 
private:
    ops_factory() = default;
    ops_factory(const ops_factory &) = delete;
 
public:
    static ops_factory & instance()
    {
        static ops_factory factory;
        return factory;
    }
 
    static void register_creation(const char key, creator_function creator)
    {
        ops_factory & factory = instance();
 
        factory._creation_data[key] = creator;
    }
 
    static object_uptr create_object(const char key)
    {
        const ops_factory & factory = instance();
 
        const auto iter = factory._creation_data.find(key);
        if (iter == factory._creation_data.end()) 
            throw std::invalid_argument("ops_factory: bad key");
 
        creator_function creator = iter->second;
        return creator();
    }
};
 
// registration
 
namespace creator_functions
{
    std::unique_ptr<operation> create_op_add()
    {
        return std::make_unique<op_add>();
    }
 
    std::unique_ptr<operation> create_op_subtract()
    {
        return std::make_unique<op_subtract>();
    }
 
    std::unique_ptr<operation> create_op_multiply()
    {
        return std::make_unique<op_multiply>();
    }
 
    std::unique_ptr<operation> create_op_divide()
    {
        return std::make_unique<op_divide>();
    }
 
    std::unique_ptr<operation> create_op_mod()
    {
        return std::make_unique<op_mod>();
    }
 
    std::unique_ptr<operation> create_op_pow()
    {
        return std::make_unique<op_pow>();
    }
 
    std::unique_ptr<operation> create_op_fact()
    {
        return std::make_unique<op_fact>();
    }
 
    std::unique_ptr<operation> create_op_unary_plus()
    {
        return std::make_unique<op_unary_plus>();
    }
 
    std::unique_ptr<operation> create_op_unary_minus()
    {
        return std::make_unique<op_unary_minus>();
    }
}
 
class static_registrator
{
private:
    static_registrator()
    {
        ops_factory & factory = ops_factory::instance();
 
        factory.register_creation('+', &creator_functions::create_op_add);
        factory.register_creation('-', &creator_functions::create_op_subtract);
        factory.register_creation('*', &creator_functions::create_op_multiply);
        factory.register_creation('/', &creator_functions::create_op_divide);
        factory.register_creation('%', &creator_functions::create_op_mod);
        factory.register_creation('^', &creator_functions::create_op_pow);
        factory.register_creation('!', &creator_functions::create_op_fact);
        factory.register_creation(-'+', &creator_functions::create_op_unary_plus);
        factory.register_creation(-'-', &creator_functions::create_op_unary_minus);
    }
 
    static static_registrator _instance;
};
 
static_registrator static_registrator::_instance;
 
// parse expression
 
class expression_parser
{
private:
    std::string str;
    std::unordered_map<char, std::size_t> prior;
 
public:
    expression_parser() = default;
    
    explicit expression_parser(std::string & expr) : str(std::move(expr))
    {
        prior.insert(std::make_pair('+', 1));
        prior.insert(std::make_pair('-', 1));
        prior.insert(std::make_pair('*', 2));
        prior.insert(std::make_pair('/', 2));
        prior.insert(std::make_pair('%', 2));
        prior.insert(std::make_pair('^', 3));
        prior.insert(std::make_pair('!', 3));
        prior.insert(std::make_pair(-'+', 4));
        prior.insert(std::make_pair(-'-', 4));
    }
 
    ~expression_parser() = default;
 
    double calculate_result()
    {
        std::stack<char> oper;
        std::stack<double> stack;
 
        if (!lays_check(str, '(', ')') && 
            !incorrect_symbol(str))
                throw std::invalid_argument("expression is incorrect");
 
        str.erase(std::remove(std::begin(str), 
                  std::end(str), ' '), 
                  std::end(str));
        stack.push(0);
 
        for (
            auto iter = std::begin(str); 
            iter != std::end(str); 
            ++iter
            )
        {
            if (*iter == '(')
                oper.push(*iter);
 
            else if (*iter == ')')
            {
                while (oper.top() != '(')
                    process_operation(stack, oper.top()),
                    oper.pop();
                oper.pop();
            }
 
            else if (is_operation(*iter))
            {
                char op_sign = *iter;
                if ((*iter == '+' || *iter == '-') && 
                    (std::begin(str) == iter || (!std::isdigit(*std::prev(iter)) && 
                     *std::prev(iter) != '.' && 
                     *std::prev(iter) != ')' && 
                     *std::prev(iter) != '!')))
                         op_sign = -op_sign;
                while (!oper.empty() && prior[oper.top()] >= prior[op_sign])
                    process_operation(stack, oper.top()),
                    oper.pop();
                oper.push(op_sign);
            }
 
            else if (std::isalpha(*iter))
            {
                auto not_alpha = std::find(iter, std::end(str), '('),
                     not_digit = std::find(not_alpha, std::end(str), ')');
                
                std::string op_fn(iter, not_alpha);
                auto op_res = std::stod(std::string(std::next(not_alpha), not_digit));
                
                if (op_fn == "sin")
                    stack.push(std::sin(op_res));
                else if (op_fn == "cos")
                    stack.push(std::cos(op_res));
                else if (op_fn == "tg")
                    stack.push(std::tan(op_res));
                else if (op_fn == "сtg")
                    stack.push(std::cos(op_res) / std::sin(op_res));
                else
                    throw std::invalid_argument("unknow function");
 
                iter = not_digit;
            }
 
            else
            {
                auto not_digit = std::find_if_not(iter, 
                                                  std::end(str), 
                                                  [this](const auto ch)
                                                  { 
                                                       return std::isdigit(ch) || ch == '.'; 
                                                  });
                stack.push(std::stod(std::string(iter, not_digit)));
                iter = std::prev(not_digit);
            }
        }
 
        while (!oper.empty())
            process_operation(stack, oper.top()), 
            oper.pop();
 
        return stack.top();
    }
 
private:
    inline bool is_operation(const char op_sign)
    {
        return op_sign == '+' || 
               op_sign == '-' || 
               op_sign == '*' || 
               op_sign == '/' || 
               op_sign == '^' || 
               op_sign == '!';
    }
 
    inline bool incorrect_symbol(std::string const & expr)
    {
        return std::all_of(std::begin(str),
                           std::end(str), 
                           [this](const auto ch)
                           {
                               return (std::isspace(ch) ||
                                       std::isdigit(ch) ||
                                       std::isalpha(ch) ||
                                       is_operation(ch) ||
                                       ch == '(' || ch == ')' || ch == '.');
                           });
    }
 
    inline bool lays_check(std::string const & expr, const char lhs, const char rhs)
    {
        std::stack<char> stack;
        for (
            const auto ch : expr
            )
        {
            if (ch == lhs) stack.push(ch);
            else if (ch == rhs) 
                if (!stack.empty()) stack.pop();                
                else 
                    return false;
        }
        
        return stack.empty();
    }
 
    inline void process_operation(std::stack<double> & stack, const char op_sign)
    {
        auto op_object = ops_factory::instance().create_object(op_sign);  
        op_object->exec(stack);
    }
};
 
int main(int argc, char* argv[])
{
    std::string expr;
    std::cout << "enter correct math expression: " << std::endl;
    while (std::cout << ">> " && std::getline(std::cin, expr) && !expr.empty())
    {
        expression_parser param(expr);
        std::cout << "result: " << param.calculate_result() << std::endl;
    }
 
    return 0;
}

#include <iostream>
#include <string>
#include <functional>
#include <unordered_map>
#include <cmath>
#include <cctype>
#include <algorithm>
#include <stack>
#include <memory>
 
// operations
// abstract class operation
 
class operation
{
public:
    virtual void exec(std::stack<double> &) const = 0;
    virtual ~operation() = default;
};
 
class op_add : public operation
{
public:
    void exec(std::stack<double> & stack) const override
    {
        const auto arg1 = stack.top();
        stack.pop();
        const auto arg2 = stack.top();
        stack.pop();
 
        stack.push(arg2 + arg1);
    }
};
 
class op_subtract : public operation
{
public:
    void exec(std::stack<double> & stack) const override
    {
        const auto arg1 = stack.top();
        stack.pop();
        const auto arg2 = stack.top();
        stack.pop();
 
        stack.push(arg2 - arg1);
    }
};
 
class op_multiply : public operation
{
public:
    void exec(std::stack<double> & stack) const override
    {
        const auto arg1 = stack.top();
        stack.pop();
        const auto arg2 = stack.top();
        stack.pop();
 
        stack.push(arg2 * arg1);
    }
};
 
class op_divide : public operation
{
public:
    void exec(std::stack<double> & stack) const override
    {
        const auto arg1 = stack.top();
        stack.pop();
        const auto arg2 = stack.top();
        stack.pop();
        if (arg1 == 0)
            throw std::invalid_argument("division by zero");
 
        stack.push(arg2 / arg1);
    }
};
 
class op_mod : public operation
{
public:
    void exec(std::stack<double> & stack) const override
    {
        const auto arg1 = stack.top();
        stack.pop();
        const auto arg2 = stack.top();
        stack.pop();
 
        stack.push(std::fmod(arg2, arg1));
    }
};
 
class op_pow : public operation
{
public:
    void exec(std::stack<double> & stack) const override
    {
        const auto arg1 = stack.top();
        stack.pop();
        const auto arg2 = stack.top();
        stack.pop();
 
        stack.push(std::pow(arg2, arg1));
    }
};
 
class op_fact : public operation
{
    double fact(double val) const
    {
        if (val == 0)
            return 1;
        return val * fact(val - 1);
    }
public:
    void exec(std::stack<double> & stack) const override
    {
        const auto arg = stack.top();
        stack.pop();
        if (arg < 0)
            throw std::invalid_argument("argument must be is greater zero");
 
        stack.push(fact(arg));
    }
};
 
class op_unary_plus : public operation
{
public:
    void exec(std::stack<double> & stack) const override
    {
        const auto arg = stack.top();
        stack.pop();
 
        stack.push(arg);
    }
};
 
class op_unary_minus : public operation
{
public:
    void exec(std::stack<double> & stack) const final override
    {
        const auto arg = stack.top();
        stack.pop();
 
        stack.push(-arg);
    }
};
 
// factory
 
class ops_factory
{
public:
    using object_uptr = std::unique_ptr<operation>;
    using creator_function = std::function<object_uptr(void)>;
 
private:
    std::unordered_map<char, creator_function> _creation_data;
 
private:
    ops_factory() = default;
    ops_factory(const ops_factory &) = delete;
 
public:
    static ops_factory & instance()
    {
        static ops_factory factory;
        return factory;
    }
 
    static void register_creation(const char key, creator_function creator)
    {
        ops_factory & factory = instance();
 
        factory._creation_data[key] = creator;
    }
 
    static object_uptr create_object(const char key)
    {
        const ops_factory & factory = instance();
 
        const auto iter = factory._creation_data.find(key);
        if (iter == factory._creation_data.end()) 
            throw std::invalid_argument("ops_factory: bad key");
 
        creator_function creator = iter->second;
        return creator();
    }
};
 
// registration
 
namespace creator_functions
{
    std::unique_ptr<operation> create_op_add()
    {
        return std::make_unique<op_add>();
    }
 
    std::unique_ptr<operation> create_op_subtract()
    {
        return std::make_unique<op_subtract>();
    }
 
    std::unique_ptr<operation> create_op_multiply()
    {
        return std::make_unique<op_multiply>();
    }
 
    std::unique_ptr<operation> create_op_divide()
    {
        return std::make_unique<op_divide>();
    }
 
    std::unique_ptr<operation> create_op_mod()
    {
        return std::make_unique<op_mod>();
    }
 
    std::unique_ptr<operation> create_op_pow()
    {
        return std::make_unique<op_pow>();
    }
 
    std::unique_ptr<operation> create_op_fact()
    {
        return std::make_unique<op_fact>();
    }
 
    std::unique_ptr<operation> create_op_unary_plus()
    {
        return std::make_unique<op_unary_plus>();
    }
 
    std::unique_ptr<operation> create_op_unary_minus()
    {
        return std::make_unique<op_unary_minus>();
    }
}
 
class static_registrator
{
private:
    static_registrator()
    {
        ops_factory & factory = ops_factory::instance();
 
        factory.register_creation('+', &creator_functions::create_op_add);
        factory.register_creation('-', &creator_functions::create_op_subtract);
        factory.register_creation('*', &creator_functions::create_op_multiply);
        factory.register_creation('/', &creator_functions::create_op_divide);
        factory.register_creation('%', &creator_functions::create_op_mod);
        factory.register_creation('^', &creator_functions::create_op_pow);
        factory.register_creation('!', &creator_functions::create_op_fact);
        factory.register_creation(-'+', &creator_functions::create_op_unary_plus);
        factory.register_creation(-'-', &creator_functions::create_op_unary_minus);
    }
 
    static static_registrator _instance;
};
 
static_registrator static_registrator::_instance;
 
// parse expression
 
class expression_parser
{
private:
    std::unordered_map<char, std::size_t> prior;
 
public:
    expression_parser()
    {
        prior.insert(std::make_pair('+', 1));
        prior.insert(std::make_pair('-', 1));
        prior.insert(std::make_pair('*', 2));
        prior.insert(std::make_pair('/', 2));
        prior.insert(std::make_pair('%', 2));
        prior.insert(std::make_pair('^', 3));
        prior.insert(std::make_pair('!', 3));
        prior.insert(std::make_pair(-'+', 4));
        prior.insert(std::make_pair(-'-', 4));
    }
    
    ~expression_parser() = default;
 
    double calc(std::string & expr)
    {
        std::stack<char> oper;
        std::stack<double> st;
 
        if (!lays_check(expr, '(', ')'))
            throw std::invalid_argument("error bracket");
        else if (!incorrect_symbol(expr))
            throw std::invalid_argument("incorrect symbol");
 
        expr.erase(std::remove(std::begin(expr),
                  std::end(expr), ' '),
                  std::end(expr));
 
        for (
            auto iter = std::begin(expr);
            iter != std::end(expr);
            ++iter
            )
        {
            if (*iter == '(')
                oper.push(*iter);
 
            else if ((*iter == ')') || (*iter == ','))
            {
                while (oper.top() != '(')
                    process_operation(st, oper.top()),
                    oper.pop();
                if (*iter == ')') oper.pop();
            }
 
            else if (is_operation(*iter))
            {
                char op_sign = *iter;
                
                if ((*iter == '+' || *iter == '-') && 
                    (std::begin(expr) == iter || (!std::isdigit(*std::prev(iter)) &&
                     *std::prev(iter) != '.' && 
                     *std::prev(iter) != ')' && 
                     *std::prev(iter) != '!')))
                         op_sign = -op_sign;
                
                while (!oper.empty() && prior[oper.top()] >= prior[op_sign])
                    process_operation(st, oper.top()),
                    oper.pop();
                oper.push(op_sign);
            }
 
            else if (std::isalpha(*iter))
            {
                auto beg = std::find(iter, std::end(expr), '('), end = beg, del = beg;
                std::stack<char> brackets;
                
                for (; 
                    end != std::cend(expr);
                    ++end
                    )
                {
                    if (*end == '(')
                        brackets.push(*end);
                    else if (*end == ')') {
                        brackets.pop();
                        if (brackets.empty())
                            break;
                    }
                    else if (*end == ',')
                        del = end;
                }
 
                std::string op_fn(iter, beg); 
                str_tolower(op_fn);
                auto op_res = calc(std::string(beg, end + 1));
                
                if (op_fn == "sin")
                    st.push(std::sin(op_res));
                else if (op_fn == "cos")
                    st.push(std::cos(op_res));
                else if (op_fn == "tg")
                    st.push(std::tan(op_res));
                else if (op_fn == "сtg")
                    st.push(std::cos(op_res) / std::sin(op_res));
                else if (op_fn == "lg")
                    st.push(std::log10(op_res));
                else if (op_fn == "ln")
                    st.push(std::log(op_res));
                else if (op_fn == "log")
                    st.push(std::logb(op_res));
                else if (op_fn == "exp")
                    st.push(std::exp(op_res));
                else if (op_fn == "pow")
                    st.push(std::pow(calc(std::string(beg + 1, del)), op_res));
                else if (op_fn == "min")
                    st.push(std::min(op_res, calc(std::string(beg + 1, del))));
                else if (op_fn == "max")
                    st.push(std::max(op_res, calc(std::string(beg + 1, del))));
                else if (op_fn == "abs")
                    st.push(std::abs(op_res));
                else if (op_fn == "sqrt")
                    st.push(std::sqrt(op_res));
                else
                    throw new std::invalid_argument("unknow function");
 
                iter = end; 
            }
 
            else
            {
                auto not_digit = std::find_if_not(iter, 
                                                  std::end(expr),
                                                  [this](const auto ch)
                                                  { 
                                                       return std::isdigit(ch) || ch == '.'; 
                                                  });
                st.push(std::stod(std::string(iter, not_digit)));
                iter = std::prev(not_digit);
            }
        }
 
        while (!oper.empty())
            process_operation(st, oper.top()), 
            oper.pop();
 
        return st.top();
    }
 
private:
    bool is_operation(const char op_sign)
    {
        return op_sign == '+' || 
               op_sign == '-' || 
               op_sign == '*' || 
               op_sign == '/' || 
               op_sign == '^' || 
               op_sign == '!';
    }
 
    bool incorrect_symbol(std::string const & expr)
    {
        return std::all_of(std::begin(expr),
                           std::end(expr),
                           [this](const auto ch)
                           {
                               return (std::isspace(ch) ||
                                       std::isdigit(ch) ||
                                       std::isalpha(ch) ||
                                       is_operation(ch) ||
                                       ch == '(' || ch == ')' || 
                                       ch == '.' || ch == ',');
                           });
    }
 
    bool lays_check(std::string const & expr, const char lhs, const char rhs)
    {
        std::stack<char> stack;
        for (
            const auto ch : expr
            )
        {
            if (ch == lhs) stack.push(ch);
            else if (ch == rhs) 
                if (!stack.empty()) stack.pop();                
                else 
                    return false;
        }
        
        return stack.empty();
    }
 
    std::string str_tolower(std::string & str)
    {
        std::transform(std::begin(str), 
                       std::end(str), 
                       std::begin(str),
                       [this](const auto ch) 
                       {
                            return std::tolower(static_cast<unsigned>(ch)); 
                       });
 
        return str;
    }
 
    void process_operation(std::stack<double> & stack, const char op_sign)
    {
        auto op_object = ops_factory::instance().create_object(op_sign);  
        op_object->exec(stack);
    }
};
 
int main(int argc, char* argv[])
{
    std::string expr;
    expression_parser param;
    while (std::cout << ">> " && std::getline(std::cin, expr) && !expr.empty())
        std::cout << "\nresult: " << param.calc(expr) << std::endl;
    return 0;
}