Очень нужны советы в реализации строкового калькулятора (как можно проще к пониманию) - C (СИ) - Ответ 13676483

@7533620 · 23.06.2019, 21:17

https://www.youtube.com/watch?v=9vmhcBpZDcE

Добавлено через 3 часа 30 минут
Осталось на си перевести

C++

struct basic_node
{
    virtual int evaluate() const = 0;
    virtual ~basic_node() = default;
};
 
struct value_node : basic_node
{
    int value;
 
    value_node(int value) : value(value) { }
 
    int evaluate() const override
    {
        return value;
    }
};
 
struct operation_node : basic_node
{
    unique_ptr<basic_node> left;
    unique_ptr<basic_node> right;
 
    operation_node(unique_ptr<basic_node> left, unique_ptr<basic_node> right) : left(std::move(left)), right(std::move(right)) { }
};
 
struct add_node : operation_node
{
    using operation_node::operation_node;
 
    int evaluate() const override
    {
        return left->evaluate() + right->evaluate();
    }
};
 
struct sub_node : operation_node
{
    using operation_node::operation_node;
 
    int evaluate() const override
    {
        return left->evaluate() - right->evaluate();
    }
};
 
struct mul_node : operation_node
{
    using operation_node::operation_node;
 
    int evaluate() const override
    {
        return left->evaluate() * right->evaluate();
    }
};
 
struct div_node : operation_node
{
    using operation_node::operation_node;
 
    int evaluate() const override
    {
        return left->evaluate() / right->evaluate();
    }
};
 
struct mod_node : operation_node
{
    using operation_node::operation_node;
 
    int evaluate() const override
    {
        return left->evaluate() % right->evaluate();
    }
};
 
struct basic_token
{
    virtual ~basic_token() = 0;
 
    virtual bool is_value() const noexcept { return false; }
 
    virtual bool is_operation() const noexcept { return false; }
};
 
basic_token::~basic_token() = default;
 
struct value_token : basic_token
{
    int value;
 
    value_token(int value) : value(value) { }
 
    bool is_value() const noexcept override { return true; }
};
 
enum operation_token_type
{
    add, sub, mul, div, mod, ob, cb
};
 
struct operation_token : basic_token
{
    operation_token_type type;
 
    operation_token(operation_token_type type) : type(type) { }
 
    bool is_operation() const noexcept override { return true; }
};
 
auto build_token_list(const string& s)
{
    vector<unique_ptr<basic_token>> result;
    for (unsigned i = 0; i < s.size(); ++i)
    {
        if (s[i] == '+')
            result.push_back(make_unique<operation_token>(operation_token_type::add));
        else if (s[i] == '-')
            result.push_back(make_unique<operation_token>(operation_token_type::sub));
        else if (s[i] == '*')
            result.push_back(make_unique<operation_token>(operation_token_type::mul));
        else if (s[i] == '/')
            result.push_back(make_unique<operation_token>(operation_token_type::div));
        else if (s[i] == '%')
            result.push_back(make_unique<operation_token>(operation_token_type::mod));
        else if (s[i] == '(')
            result.push_back(make_unique<operation_token>(operation_token_type::ob));
        else if (s[i] == ')')
            result.push_back(make_unique<operation_token>(operation_token_type::cb));
        else
        {
            unsigned j = i + 1;
            while (j < s.size() && s[j] >= '0' && s[j] <= '9')
                ++j;
            int n;
            from_chars(s.data() + i, s.data() + j, n, 10);
            i = j - 1;
            result.push_back(make_unique<value_token>(n));
        }
    }
    return result;
}
 
 
 
 
 
auto token(span<unique_ptr<basic_token>>::iterator i) -> decltype(auto) { return *(*i); };
 
auto parse_expr(span<unique_ptr<basic_token>>)   -> pair<span<unique_ptr<basic_token>>, unique_ptr<basic_node>>;
auto parse_term(span<unique_ptr<basic_token>>)   -> pair<span<unique_ptr<basic_token>>, unique_ptr<basic_node>>;
auto parse_factor(span<unique_ptr<basic_token>>) -> pair<span<unique_ptr<basic_token>>, unique_ptr<basic_node>>;
 
// E -> E + T | E - T | T
// T -> T * F | T / F | T % F | F
// F -> ( E ) | NUMBER
 
auto parse_factor(span<unique_ptr<basic_token>> tkns) -> pair<span<unique_ptr<basic_token>>, unique_ptr<basic_node>>
{
    auto& cur = token(tkns.begin());
    if (!cur.is_operation())
        return { tkns.subspan(1), make_unique<value_node>(static_cast<value_token&>(cur).value) };
    auto& open_bracket = static_cast<operation_token&>(cur);
    if (open_bracket.type != operation_token_type::ob)
        throw runtime_error("Expected \'(\'");
    auto [s, n] = parse_expr(tkns.subspan(1));
    auto& close_bracket = static_cast<operation_token&>(token(s.begin()));
    if (close_bracket.type != operation_token_type::cb)
        throw runtime_error("Expected \')\'");
    return { s.subspan(1), std::move(n) };
}
 
auto parse_term(span<unique_ptr<basic_token>> tkns) -> pair<span<unique_ptr<basic_token>>, unique_ptr<basic_node>>
{
    unique_ptr<basic_node> left;
    auto [s, n] = parse_factor(tkns);
    tkns = s;
    left = std::move(n);
    while (true)
    {
        if (!tkns.size())
            return { { }, std::move(left) };
        auto& cur = token(tkns.begin());
        if (!cur.is_operation())
            throw runtime_error("Expected operation");
        auto& op = static_cast<operation_token&>(cur);
        if (op.type != operation_token_type::mul && op.type != operation_token_type::div && op.type != operation_token_type::mod)
            return { tkns, std::move(left) };
        auto right = parse_factor(tkns.subspan(1));
        tkns = right.first;
        switch (op.type)
        {
            case operation_token_type::mul:
                left = make_unique<mul_node>(mul_node(std::move(left), std::move(right.second)));
                break;
            case operation_token_type::div:
                left = make_unique<mul_node>(mul_node(std::move(left), std::move(right.second)));
                break;
            case operation_token_type::mod:
                left = make_unique<mul_node>(mul_node(std::move(left), std::move(right.second)));
                break;
        }
    }
}
 
auto parse_expr(span<unique_ptr<basic_token>> tkns) -> pair<span<unique_ptr<basic_token>>, unique_ptr<basic_node>>
{
    unique_ptr<basic_node> left;
    auto [s, n] = parse_term(tkns);
    tkns = s;
    left = std::move(n);
    while (true)
    {
        if (!tkns.size())
            return { { }, std::move(left) };
        auto& cur = token(tkns.begin());
        if (!cur.is_operation())
            throw runtime_error("Expected operation");
        auto& op = static_cast<operation_token&>(cur);
        if (op.type != operation_token_type::add && op.type != operation_token_type::sub)
            return { tkns, std::move(left) };
        auto right = parse_term(tkns.subspan(1));
        tkns = right.first;
        switch (op.type)
        {
            case operation_token_type::add:
                left = make_unique<add_node>(std::move(left), std::move(right.second));
                break;
            case operation_token_type::sub:
                left = make_unique<sub_node>(std::move(left), std::move(right.second));
                break;
        }
    }
}
 
auto calc_expression(const string& s)
{
    string spaces_removed;
    copy_if(s.begin(), s.end(), back_inserter(spaces_removed), [](char c){ return c != ' '; });
    auto invalid_chars_count = count_if(spaces_removed.begin(), spaces_removed.end(), [](char c)
    {
        return c != '+' && c != '-' && c != '*' && c != '/' && c != '%' && c != '(' && c != ')' && (c < '0' || c > '9');
    });
    if (invalid_chars_count)
        throw runtime_error("Invalid characters detected");
    auto tkns = build_token_list(spaces_removed);
    if (!tkns.size())
        throw runtime_error("Empty expression");
    auto result = parse_expr(tkns);
    if (result.first.size())
        throw runtime_error("Invalid expression");
    return result.second->evaluate();
}
 
int main()
{
    cout << "Type \'EXIT\' for exit" << endl << endl;
    while (true)
    {
        string expression;
        getline(cin, expression);
        if (expression == "EXIT")
            break;
        try { cout << calc_expression(expression) << endl << endl; }
        catch (runtime_error e) { cerr << e.what() << endl << endl; }
    }
    return 0;
}

span.hpp

C++

template<typename Tp>
    class span
    {
        static_assert(std::is_same_v<std::remove_volatile_t<std::remove_reference_t<Tp>>, Tp>, "Span must have a non-reference, non-volatile value_type");
 
    public:
        using value_type = Tp;
        using pointer = value_type*;
        using const_pointer = const value_type*;
        using reference = value_type&;
        using const_reference = const value_type&;
        using iterator = pointer;
        using const_iterator = const_pointer;
        using reverse_iterator = std::reverse_iterator<iterator>;
        using const_reverse_iterator = std::reverse_iterator<const_iterator>;
 
    private:
        pointer data_ = nullptr;
        u64 size_ = 0;
 
    public:
        span() noexcept = default;
 
        span(const span&) noexcept = default;
 
        span& operator=(const span&) noexcept = default;
 
        constexpr span(Tp* begin, u64 count) : data_(begin), size_(count) { }
 
        constexpr span(Tp* begin, Tp* end) : data_(begin)
        {
            if (end < begin)
                throw std::out_of_range("span::span: Invalid [begin, end) range");
            if ((reinterpret_cast<u64>(end) - reinterpret_cast<u64>(begin)) % sizeof(Tp))
                throw std::out_of_range("span::span: Invalid [begin, end) range");
            size_ = end - begin;
        }
 
        template<typename Container>
        constexpr span(Container& container) : span(container.data(), container.size()) { }
 
        template<typename T>
        constexpr span(std::initializer_list<T> l) : span(l.begin(), l.end()) { }
 
        template<u64 N>
        constexpr span(Tp(&arr)[N]) : span(arr, N) { }
 
        constexpr void clear() noexcept
        {
            data_ = nullptr;
            size_ = 0;
        }
 
        constexpr u64 size() const noexcept
        {
            return size_;
        }
 
        constexpr bool empty() const noexcept
        {
            return !size_;
        }
 
        constexpr span subspan(u64 begin = 0, u64 count = std::numeric_limits<u64>::max()) const
        {
            if (count == std::numeric_limits<u64>::max())
                return span(data_ + begin, data_ + size_);
            return span(data_ + begin, data_ + begin + count);
        }
 
        constexpr reference front() const
        {
            return data_[0];
        }
 
        constexpr reference back() const
        {
            return data_[size_ - 1];
        }
 
        constexpr pointer data() const noexcept
        {
            return data_;
        }
 
        constexpr reference operator[](u64 i) const
        {
            return data_[i];
        }
 
        constexpr reference at(u64 i) const
        {
            if (i >= size_)
                throw std::out_of_range("span: Out of range");
            return operator[](i);
        }
 
        constexpr iterator begin() const noexcept
        {
            return data_;
        }
 
        constexpr iterator end() const noexcept
        {
            return data_ + size_;
        }
 
        constexpr const_iterator cbegin() const noexcept
        {
            return data_;
        }
 
        constexpr const_iterator cend() const noexcept
        {
            return data_ + size_;
        }
 
        constexpr reverse_iterator rbegin() const noexcept
        {
            return reverse_iterator(data_ + size_);
        }
 
        constexpr reverse_iterator rend() const noexcept
        {
            return reverse_iterator(data_);
        }
 
        constexpr const_reverse_iterator crbegin() const noexcept
        {
            return reverse_iterator(data_ + size_);
        }
 
        constexpr const_reverse_iterator crend() const noexcept
        {
            return reverse_iterator(data_);
        }
    };
 
    template<typename Container>
    span(Container& container) -> span<std::remove_pointer_t<decltype(container.data())>>;
 
    template<typename T>
    span(std::initializer_list<T>) -> span<const T>;

Вернуться к обсуждению:
Очень нужны советы в реализации строкового калькулятора (как можно проще к пониманию) C (СИ)

Другие темы раздела
C (СИ) Рекурсия. Найти n-ый член ряда чисел, заданых формулой https://www.cyberforum.ru/ c-beginners/ thread2475411.html Задана формула Fi=sqrt(Fi-1)+4*i, первый член ряда чисел F1=1, i=2,3... . Нужно написать рекурсивную функцию, которая находит n-ый член ряда чисел.	Подсчитать количество символов в строке больше символа «К» и вывести на экран C (СИ) Ввести строку символов. Подсчитать количество символов в строке больше символа «К» и вывести на экран. Собственно вот задание, не могу сообразить, что тут нужно: цикл, условие, или что-то еще? Добавлено через 12 минут Если можно, то на чистом си. спасибо. Инициализируется через char, а выводится через puts.
C (СИ) Вывод в порядке возрастания размеров файлов Как вывести файлы и их размер? #include <stdio.h> #include <string.h> #include <errno.h> #include <dirent.h> #define DIRNAME "." #define OFNAME "out.log" https://www.cyberforum.ru/ c-beginners/ thread2475356.html	C (СИ) Поменять строки матрицы местами: строка с минимальным элементом и первая строка Нужна помощь в решении задачи на языке С. Благодарствую заранее) Задача: Составить программу, которая будет генерировать случайные числа в интервале и заполнять ими двумерный массив размером 10 на 10. В массиве необходимо найти номер строки с минимальным элементом. Поменять строки массива местами, строка с минимальным элементом и первую строку массива. Организовать удобный вывод на экран. https://www.cyberforum.ru/ c-beginners/ thread2475188.html
Используя только операции сложения и вычитания, найти частное от деления нацело N на K, а также остаток от этого деления C (СИ) Нужно решение задачи на языке С. Заранее благодарю))) Задача: Даны целые положительные числа N и K. Используя только операции сложения и вычитания, найти частное от деления нацело N на K, а также остаток от этого деления	C (СИ) Найти длины отрезков AC и BC и их сумму Нужна помощь в решении задачи, язык C Задача: Даны три точки A, B, C на числовой оси. Найти длины отрезков AC и BC и их сумму. Заранее спасибо) https://www.cyberforum.ru/ c-beginners/ thread2475182.html
C (СИ) MV Studio Express 2012, компилятор си не разрешает объявлять переменные вне начала функции компилятор си не разрешает объявлять переменные вне начала функции. по googlu 99 версия компилятора. вопрос? как это исправить в MV Studio 2012.+ Добавлено через 4 часа 12 минут У меня MV Studio Express 2012: пишу на си. вопрос? как сделать так, что-бы объявлять переменные и константы, https://www.cyberforum.ru/ c-beginners/ thread2475100.html	не работает strcat, отладчик выбрасывает окно с ошибкой C (СИ) MV Studio Express 2012,windows 7 64, Необработанное исключение по адресу 0x000000013F2B1099 в expwinapiFile.exe: 0xC0000005: нарушение прав доступа при записи по адресу 0x000000013F2B2217. strcat(strPatchF, strPatchFile); #define _CRT_SECURE_NO_WARNINGS #include <windows.h>
C (СИ) Вывод на экран содержимого текущего каталога в порядке возрастания размеров файлов Будет работать во FreeBSD? #include <sys/types.h> #include <dirent.h> #include <unistd.h> #include <sys/stat.h> #include <stdio.h> #include <stdlib.h> #include <string.h> struct LE { https://www.cyberforum.ru/ c-beginners/ thread2474774.html	C (СИ) В каждой строке все слова, длина которых превышает среднюю длину слов в строке, сократить до средней длины https://www.cyberforum.ru/ c-beginners/ thread2474767.html Не могу выполнить задание. пока что только удалось посчитать среднюю длину слов. здесь фаил(ввод/вывод), буду благодарна за любую помощь #include<stdio.h> #include<conio.h> #include<string.h> #include<stdlib.h> int main(int argc, char **argv) { char bul, bu2; if (argc<=1)
Пакетная обработка C (СИ) Имеется файл ini.txt. Как правильно и грамотно его распарсить. Впервые делаю пакетную обработку. И хочется учесть все подводные камни. #include <stdio.h> #include <stdlib.h> int main() { FILE *ptr; char adress; if ((ptr = fopen ("D:\ini.txt","r")) == NULL) {	C (СИ) Подскажите, данная программа выполнена на языке C? https://www.cyberforum.ru/ c-beginners/ thread2474585.html #include <stdio.h> #include <iostream> #include <cstdlib> #include <ctime> #include <math.h> using namespace std; int rrand(int range_min, int range_max) { return rand() % (range_max - range_min + 1) + range_min; } int main() {, setlocale(LC_ALL, "rus"); cout << "Массив:" << endl; int A={}; int i,max,sum,N; srand(time(NULL)); for (i=0; i<17; i++) { A = rrand(-170,170); cout << A <<...

	23.06.2019, 21:17

Очень нужны советы в реализации строкового калькулятора (как можно проще к пониманию) - C (СИ) - Ответ 13676483

Решение