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

@zarko97 · Регистрация: 11.10.2015

Author24 — интернет-сервис помощи студентам

Пишу парсер мат. выражений. Столкнулся с проблемкой: как обозначить унарные операции + и - ?
Есть мапа приоритетов:

C++

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));

Я решил взять эти операции в скобки. Является ли это решение корректным?

Добавлено через 1 минуту
Так же хотелось узнать стоит ли туда запихивать различные мат.функции и лепить им приоритет?

Добавлено через 43 секунды

C++

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

и тд.

@zarko97 · 22.07.2017, 16:24 **[ТС]**

Сообщение от Renji

Не стандартный доступ к мапе

это как понять? а что есть тогда "стандартный" ??

@Renji · 22.07.2017, 16:38

Сообщение от zarko97

это как понять? а что есть тогда "стандартный" ??

~~Не стандартный~~ не унифицированный. Мап создается не чтоб было, а чтоб ужать switch(opcode) в одну простую строчку map[opcode].priority. Если в итоге доступ к map получается какой-то хитровывернутый (для бинарных операций так, для унарных сяк) это какое-то плохое, негодное ужимание.

@zarko97 · 22.07.2017, 18:41 **[ТС]**

Renji, ну хз... по-моему проще к плюсику/минусику скобочки подрисовать, чем отдельную мапу городить или фабрику перестраивать

Добавлено через 1 минуту
Renji, да мне самому этот вариант оч не нравится, но пока так оставлю, потом под енамы переделаю, не хочу зацикливаться на этом задании

@zarko97 · 25.07.2017, 17:06 **[ТС]**

Вот получил более менее неплохой парсер. Результат:

@zarko97 · 28.07.2017, 00:23 **[ТС]**

Сообщение от Renji

но зачем там stack

пришлось сделать, мне не хочется постоянно писать stack.top(); stack.pop();
почему бы как в нормальных языках сделать pop не void непонятно...

@~~dawn artist~~ · 28.07.2017, 00:34

Сообщение от zarko97

почему бы как в нормальных языках

Список нормальных языков в студию.

Сообщение от zarko97

сделать pop не void непонятно...

Потому что есть такая вещь в C++ как исключения. И есть некоторые гарантии, которые мы хотим, чтобы предоставляли методы стека. Гарантии относительно поведения при возникающих при работе этих методов исключений. И с T stack::pop() невозможно предоставить такие гарантии.

@Renji · 28.07.2017, 00:41

Сообщение от zarko97

пришлось сделать, мне не хочется постоянно писать stack.top(); stack.pop();
почему бы как в нормальных языках сделать pop не void непонятно...

Не, не. Вопрос был не про то, почему вы не использовали std::stack. Вопрос в том, чем вам не мил тот стек, в который автоматические переменные складываются. Рекурсивное решение которое я вам с самого начала предлагал, использует именно его. Единственная проблема с ним - достаточно глубокая рекурсия может переполнить стек. Но я слабо себе представляю что у вас там за выражение такое должно быть, чтоб стек переполнился.

@zarko97 · 28.07.2017, 13:16 **[ТС]**

daun-autist, как минимум ява или шарп, pop там не void

@~~dawn artist~~ · 28.07.2017, 13:31

zarko97, ну так там копирования объектов нет, там только ссылки передаются и возвращаются из функций. Исключений при копировании ссылок не получишь.

В общем, читай http://www.gotw.ca/gotw/008.htm. Там ответ на вопрос "почему pop возвращает void".

Добавлено через 8 минут

Сообщение от daun-autist

Там ответ на вопрос "почему pop возвращает void".

Хотя я наврал. Там не полный ответ. Т.е. его там нет. Ответ есть в его книге и эта ссылка — только первый вопрос из серии о том, как сделать стек exception safe и neutral. Почему с T Stack::pop() нельзя предоставить strong exception safety guarantees по ссылке не объясняется.

@zarko97 · 28.07.2017, 15:38 **[ТС]**

Renji, а как по вашему отлов ошибок организовать? в ходе вычисления или сделать независимый цикл и там проверять?

@Renji · 28.07.2017, 16:18

Сообщение от zarko97

Renji, а как по вашему отлов ошибок организовать?

Ну написано же было:

C++

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

@zarko97 · 29.07.2017, 15:59 **[ТС]**

Renji, вот более-менее полубыдлосорс

C++

#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;
}

@zarko97 · 31.07.2017, 22:18 **[ТС]**

up

C++

#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;
}

@zarko97 · 31.07.2017, 23:20 **[ТС]**

result:

@zarko97 279 / 39 / 13 Регистрация: 11.10.2015 Сообщений: 405
	22.07.2017, 16:24 [ТС]	21
	Сообщение от Renji Не стандартный доступ к мапе это как понять? а что есть тогда "стандартный" ?? 0

@~~dawn artist~~ Заблокирован
	28.07.2017, 00:34	26
	Сообщение от zarko97 почему бы как в нормальных языках Список нормальных языков в студию. Сообщение от zarko97 сделать pop не void непонятно... Потому что есть такая вещь в C++ как исключения. И есть некоторые гарантии, которые мы хотим, чтобы предоставляли методы стека. Гарантии относительно поведения при возникающих при работе этих методов исключений. И с `T stack::pop()` невозможно предоставить такие гарантии. 0

@Renji 2784 / 1937 / 570 Регистрация: 05.06.2014 Сообщений: 5,602
	28.07.2017, 00:41	27
	Сообщение от zarko97 пришлось сделать, мне не хочется постоянно писать stack.top(); stack.pop(); почему бы как в нормальных языках сделать pop не void непонятно... Не, не. Вопрос был не про то, почему вы не использовали std::stack. Вопрос в том, чем вам не мил тот стек, в который автоматические переменные складываются. Рекурсивное решение которое я вам с самого начала предлагал, использует именно его. Единственная проблема с ним - достаточно глубокая рекурсия может переполнить стек. Но я слабо себе представляю что у вас там за выражение такое должно быть, чтоб стек переполнился. 0

@zarko97 279 / 39 / 13 Регистрация: 11.10.2015 Сообщений: 405
	28.07.2017, 15:38 [ТС]	30
	Renji, а как по вашему отлов ошибок организовать? в ходе вычисления или сделать независимый цикл и там проверять? 0

Новые блоги и статьи
Как написать микросервис на Go/Golang с Kafka и GitHub CI/CD InfoMaster 14.01.2025 Определение микросервиса, преимущества использования Go/ Golang Микросервис – это архитектурный подход к разработке программного обеспечения, при котором приложение состоит из небольших, независимо. . .	Как написать микросервис с нуля на C# с RabbitMQ, CQRS и CI/CD InfoMaster 14.01.2025 В современном мире разработки программного обеспечения микросервисная архитектура стала стандартом де-факто для создания масштабируемых и гибких приложений. Этот архитектурный подход предполагает. . .	Как создать интернет-магазин на PHP и JavaScript InfoMaster 14.01.2025 В современном мире электронная коммерция стала неотъемлемой частью бизнеса. Создание собственного интернет-магазина открывает широкие возможности для предпринимателей, позволяя достичь большей. . .	Как написать Тетрис на Ассемблере InfoMaster 14.01.2025 Тетрис – одна из самых узнаваемых и популярных компьютерных игр, созданная в 1984 году советским программистом Алексеем Пажитновым. За прошедшие десятилетия она завоевала симпатии миллионы людей по. . .	Как создать игру "Танчики" на Unity3d и C# InfoMaster 14.01.2025 Разработка игр – это увлекательный процесс, сочетающий в себе творчество и технические навыки. В этой статье мы рассмотрим создание классической игры "Танчики" с использованием Unity3D и языка. . .	Организую платный онлайн микро-курс по доработке Android-клиента Telegram _Ivana 14.01.2025 Официальная версия и распространенные форки не полностью устраивают? Сделай свою кастомную версию клиента! 4 занятия по 2 часа (2 недели пн, ср 19:00-21:00 по Москве). Первое вводное занятие. . .
Как создать приложение для фитнеса для iOS/iPhone на Kotlin InfoMaster 14.01.2025 Создание собственного фитнес-приложения — это не только захватывающий, но и полезный процесс, ведь оно может стать вашим верным помощником на пути к здоровому и активному образу жизни. В современных. . .	Как создать приложение магазина для iOS/iPhone на Swift InfoMaster 14.01.2025 Введение в разработку iOS-приложений Разработка приложений для iPhone и других устройств на базе iOS открывает огромные возможности для создания инновационных мобильных решений. В данной статье мы. . .	Это работает. Скорость асинхронной логики велика. Вопрос видимо останется в стабильности. Плата - огонь! Hrethgir 13.01.2025 По прошлому проекту в Logisim Evolution https:/ / www. cyberforum. ru/ blogs/ 223907/ blog8781. html прилагаю файл архива проекта в Gowin Eda. Восьмибитный счётчик из сумматора+ генератор сигнала. . .	UserScript для подсветки кнопок языков программирования в зависимости от текущего раздела volvo 13.01.2025 В результате работы этого скрипта подсвечиваются нужные кнопки не только в форме быстрого ответа, но и при редактировании сообщения: / / ==UserScript== / / @name CF_DefaultLangSelect / / . . .	Введение в модели и алгоритмы машинного обучения InfoMaster 12.01.2025 Машинное обучение представляет собой одну из наиболее динамично развивающихся областей искусственного интеллекта, которая фокусируется на разработке алгоритмов и методов, позволяющих компьютерам. . .	Как на Python создать нейросеть для решения задач InfoMaster 12.01.2025 В контексте стремительного развития современных технологий особое внимание уделяется таким инструментам, как нейросети. Эти структуры, вдохновленные биологическими нейронными сетями, используются для. . .

@Renji 2784 / 1937 / 570 Регистрация: 05.06.2014 Сообщений: 5,602
	22.07.2017, 16:38	22
	Сообщение от zarko97 это как понять? а что есть тогда "стандартный" ?? ~~Не стандартный~~ не унифицированный. Мап создается не чтоб было, а чтоб ужать switch(opcode) в одну простую строчку map[opcode].priority. Если в итоге доступ к map получается какой-то хитровывернутый (для бинарных операций так, для унарных сяк) это какое-то плохое, негодное ужимание. 0

@zarko97 279 / 39 / 13 Регистрация: 11.10.2015 Сообщений: 405
	22.07.2017, 18:41 [ТС]	23
	Renji, ну хз... по-моему проще к плюсику/минусику скобочки подрисовать, чем отдельную мапу городить или фабрику перестраивать Добавлено через 1 минуту Renji, да мне самому этот вариант оч не нравится, но пока так оставлю, потом под енамы переделаю, не хочу зацикливаться на этом задании 0

@zarko97 279 / 39 / 13 Регистрация: 11.10.2015 Сообщений: 405
	25.07.2017, 17:06 [ТС]	24
	Вот получил более менее неплохой парсер. Результат: Миниатюры 0

@zarko97 279 / 39 / 13 Регистрация: 11.10.2015 Сообщений: 405
	28.07.2017, 00:23 [ТС]	25
	Сообщение от Renji но зачем там stack пришлось сделать, мне не хочется постоянно писать stack.top(); stack.pop(); почему бы как в нормальных языках сделать pop не void непонятно... 0

@zarko97 279 / 39 / 13 Регистрация: 11.10.2015 Сообщений: 405
	28.07.2017, 13:16 [ТС]	28
	daun-autist, как минимум ява или шарп, pop там не void 0

@~~dawn artist~~ Заблокирован
	28.07.2017, 13:31	29
	zarko97, ну так там копирования объектов нет, там только ссылки передаются и возвращаются из функций. Исключений при копировании ссылок не получишь. В общем, читай http://www.gotw.ca/gotw/008.htm. Там ответ на вопрос "почему pop возвращает void". Добавлено через 8 минут Сообщение от daun-autist Там ответ на вопрос "почему pop возвращает void". Хотя я наврал. Там не полный ответ. Т.е. его там нет. Ответ есть в его книге и эта ссылка — только первый вопрос из серии о том, как сделать стек exception safe и neutral. Почему с `T Stack::pop()` нельзя предоставить strong exception safety guarantees по ссылке не объясняется. 1

@zarko97 279 / 39 / 13 Регистрация: 11.10.2015 Сообщений: 405
	31.07.2017, 23:20 [ТС]	34
	result: Миниатюры 0