Парсер арифметических выражений - C++ - Ответ 10656442

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

Вернуться к обсуждению:
Парсер арифметических выражений C++

Следующий ответ

Другие темы раздела
C++ Отрисовка примитивов в чужом приложении d3d9 https://www.cyberforum.ru/ cpp-beginners/ thread2019223.html Всем доброго времени суток! Есть задача вывести примитив в чужом приложении. Хук работает прекрасно, все отрисовывается, но только не примитив. Прошу правок в мой листинг отрисовки примитива: Vertex3D Triangle = { { 10.0f, 10.0f, 1.0f, D3DCOLOR_XRGB(255, 0, 0) }, { 120.0f, 10.0f, 1.0f, D3DCOLOR_XRGB(255, 0, 0) }, { 120.0f, 120.0f, 1.0f, D3DCOLOR_XRGB(255, 0, 0) }, { 10.0f,...	Как остановить цикл? C++ #include <iostream> #include <algorithm> #include <math.h> using namespace std; int main() { int a; int n; cin>>n;
C++ Нужно ли для изучения OpenGL знать WinApi https://www.cyberforum.ru/ cpp-beginners/ thread2019197.html Приветствую. Изучаю С++. Вот решил попробовать работу с графикой и задался таким вопросом...	C++ Стековая реализация проверки правильности скобочной последовательности Надо проверить, верна ли скобочная последовательность. Решение с помощью стека. Программа ломается на самом простом тесте(лол) : (). Но я не понимаю, почему так происходит, и как это поправить. #include <iostream> #include <stack> #include <stdio.h> using namespace std; int main() { stack<char> br; https://www.cyberforum.ru/ cpp-beginners/ thread2019188.html
C++ В массиве определить количество элементов, у которых оба соседних элемента меньше данного Дан массив, состоящий из целых чисел. Напишите программу, которая в данном массиве определит количество элементов, у которых два соседних и, при этом, оба соседних элемента меньше данного. Входные данные Сначала задано число N — количество элементов в массиве (1N100). Далее через пробел записаны N чисел — элементы массива. Массив состоит из целых чисел. Выходные данные Необходимо вывести...	C++ Написал программу для решения квадратных уравнений, но не получается подогнать ее под нужные условия https://www.cyberforum.ru/ cpp-beginners/ thread2019179.html Дано условие : На вход вашей программе в стандартном вводе даны действительные коэффициенты A, B и C уравнения Ax² + Bx + C = 0. Выведите все его различные действительные корни в любом порядке. Гарантируется, что хотя бы один из коэффициентов не равен нулю. и вот мой код. #include <iostream> #include <algorithm> #include <cmath> using namespace std; int main(){ double A,B,C,D,x,x1; ...
C++ Чтение и запись значения по известному адресу Нужно реализовать чтение и запись переменной по адресу. Конкретно: есть флеш-игра, есть программа Cheat Engine, и есть значение в этой игре, которое я хочу менять автоматически. Искал ответы на эту тему, однако все они приводят к ошибке и закрытию приложения, вероятно проблема заключается в том, что у меня нет прав читать и записывать что-либо по данному адресу. CE показывает и адрес ячейки, и её... https://www.cyberforum.ru/ cpp-beginners/ thread2019176.html	Не запускается отладка в Visual Studio C++ Скопировал простую программу для С++ в Visual Studio 2017 #include "stdafx.h" #include <iostream> using namespace std; int main() { cout << "Hello, World\n"; return 0;
C++ Для индекса требуется массив или указатель https://www.cyberforum.ru/ cpp-beginners/ thread2019109.html Вот весь код: #include "stdafx.h" #include<iostream> #include<string> #include<vector> #include<algorithm> #include<cmath> // using namespace std; //	C++ Объясните синтаксис функции в С++ https://www.cyberforum.ru/ cpp-beginners/ thread2019101.html Допустим у меня есть код, суть которого состоит в нахождении корня, абсолютного модуля, косинуса числа, которое вводит пользователь void print (double); using namespace std; int main() { double num, result;
C++ Кроссплатформенный символ перевода строки Есть ли в плюсах кросплатформенный символ перевода строки? Нужно для создания файлов .txt.	C++ Iostream и функции из других библиотек Здравствуйте. При подключении iostream у меня появляется возможность использовать функции из других библиотек, вроде math.h или type.h, т.е. например #include <iostream> int main() { isdigit(2); ceil(12.3); } такой код спокойно компилируется. И меня бы это не смущало, если бы он нормально компилировался везде, а не только у меня. Да и обучению это тоже очень сильно мешает. Отсюда... https://www.cyberforum.ru/ cpp-beginners/ thread2019092.html

Новые блоги и статьи
Обработка числовой информации hw_wired 28.01.2025 Введение в обработку числовой информации В современном мире обработка числовой информации стала неотъемлемой частью как профессиональной деятельности, так и повседневной жизни. Электронные таблицы. . .	Мультимедиа hw_wired 28.01.2025 Введение в мультимедийные технологии В современном мире мультимедийные технологии стали неотъемлемой частью нашей жизни, проникнув во все сферы человеческой деятельности. Термин "мультимедиа". . .	Обработка текстовой информации hw_wired 28.01.2025 Введение в обработку текстовой информации В современном мире обработка текстовой информации играет фундаментальную роль в различных сферах человеческой деятельности. Текстовые редакторы стали. . .	Обработка графической информации hw_wired 28.01.2025 Введение в компьютерную графику Компьютерная графика стала неотъемлемой частью современного цифрового мира, пройдя впечатляющий путь развития от простейших черно-белых изображений до сложных. . .	Python в Алгоритмике: Решение задач hw_wired 28.01.2025 Введение в Python и Алгоритмику В современном мире программирование стало неотъемлемой частью образования и профессионального развития. Python зарекомендовал себя как один из самых популярных и. . .	Компьютер как универсальное устройство для работы с информацией hw_wired 28.01.2025 Введение в устройство компьютера Компьютер представляет собой универсальное электронное устройство, предназначенное для автоматической обработки информации. В современном мире компьютер стал. . .
Информация и информационные процессы hw_wired 28.01.2025 Понятие информации и ее виды В современном мире информация является одним из фундаментальных понятий, пронизывающих все сферы человеческой деятельности. Под информацией понимают любые сведения об. . .	Алгоритмика hw_wired 28.01.2025 Введение: Основы алгоритмики и её роль в информатике В современном мире программирование и алгоритмическое мышление стали неотъемлемой частью образования и профессиональной деятельности. . . .	Информационное моделирование hw_wired 28.01.2025 Введение в информационное моделирование В современном мире информационное моделирование стало неотъемлемой частью научной, образовательной и профессиональной деятельности. Это мощный инструмент. . .	Объекты и их имена hw_wired 28.01.2025 Введение: Основы объектного подхода и их роль в информатике В современном мире информационных технологий объектный подход стал фундаментальным принципом организации и обработки информации. Этот. . .	Элементы алгоритмизации hw_wired 28.01.2025 Основы алгоритмизации В современном мире алгоритмы играют фундаментальную роль в развитии информационных технологий и программирования. Понимание основ алгоритмизации является ключевым элементом в. . .	Человек и информация hw_wired 28.01.2025 Введение: роль информации в познании мира В современном мире информация играет фундаментальную роль в процессе познания окружающей действительности. Она представляет собой совокупность сведений об. . .

	31.07.2017, 22:18