Форум программистов, компьютерный форум CyberForum.ru

Парсер для математических выражений - C++

Войти
Регистрация
Восстановить пароль
Другие темы раздела
C++ Убрать/скрыть окно консоли http://www.cyberforum.ru/cpp-beginners/thread1493471.html
Всем привет!Я пишу на notepad++,компилирую через командную строку.Как мне убрать консольное окно?Заранее благодарен!
C++ ReadProcessMemory медленно читает значение адреса while (true) { if (isRun) { try { ReadProcessMemory(ProcessHandle, (void*)TimeAddress, &Time, sizeof(osuTime), NULL); std::cout << Time << std::endl; } catch (const std::exception&) {} } http://www.cyberforum.ru/cpp-beginners/thread1493470.html
ReadProcessMemory медленно читает значение адреса C++
while (true) { if (isRun) { try { ReadProcessMemory(ProcessHandle, (void*)TimeAddress, &Time, sizeof(osuTime), NULL); std::cout << Time << std::endl; } catch (const std::exception&) {} }
C++ Вычислить значения функции на заданном интервале
Написать программу вычисления функции y на заданном промежутке с шагом 0.2 и построить график функции y, причем y={e}^{-(x+0.8)} при х>3.61 y=1 при x\in \left y=0.5x при x<0
C++ Заполнить квадратную матрицу натуральными числами по спирали http://www.cyberforum.ru/cpp-beginners/thread1493450.html
Составить программу, которая заполняет квадратную матрицу порядка n натуральными числами 1, 2, 3, …, n2, записывая их в нее «по спирали» против часовой стрелки.
C++ Вычислить сумму n членов заданного ряда Вычислить сумму n членов ряда согласно условию задачи: x+{x}^{2}/2!+{x}^{4}/4!+... подробнее

Показать сообщение отдельно
Мизантроп_Лол
13 / 13 / 2
Регистрация: 26.02.2013
Сообщений: 285
Завершенные тесты: 1
06.07.2015, 16:46  [ТС]     Парсер для математических выражений
Вот что у меня получилось. Может быть кому-нибудь пригодится. Ну а более опытных форумчан, попрошу покритиковать код.

calculator.h
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
#ifndef FUNC_TREE_H_INCLUDED
#define FUNC_TREE_H_INCLUDED
 
#include <math.h>
#include <string>
#include <iostream>
 
//pi / 180
const double TO_RAD_KOEF = 0.017453292519;
 
class Func
{
    public:
        virtual int priority() = 0;
        virtual double calculate(double x) = 0;
 
        Func *left = nullptr;
        Func *right = nullptr;
};
 
class Root : public Func
{
    public:
        int priority() {return 665;}
        double calculate(double x) {return right->calculate(x);}
};
 
class Add : public Func
{
    public:
        int priority() {return 1;}
        double calculate(double x) {return left->calculate(x) + right->calculate(x);}
};
 
class Sub : public Func
{
    public:
        int priority() {return 1;}
        double calculate(double x) {return left->calculate(x) - right->calculate(x);}
};
 
class Mul : public Func
{
    public:
        int priority() {return 2;}
        double calculate(double x) {return left->calculate(x) * right->calculate(x);}
};
 
class Div : public Func
{
    public:
        int priority() {return 2;}
        double calculate(double x) {return left->calculate(x) / right->calculate(x);}
};
 
class Power : public Func
{
    public:
        int priority() {return 3;}
        double calculate(double x) {return pow(left->calculate(x), right->calculate(x));}
};
 
class Sqrt : public Func
{
    public:
        int priority() {return 3;}
        double calculate(double x) {return pow(left->calculate(x), 1.0/right->calculate(x));}
};
 
inline double toRad(double deg)
{
    return TO_RAD_KOEF * deg;
}
 
class Sinus : public Func
{
    public:
        int priority() {return 3;}
        double calculate(double x) {return sin(toRad(right->calculate(x)));}
};
 
class Cosinus : public Func
{
    public:
        int priority() {return 3;}
        double calculate(double x) {return cos(toRad(right->calculate(x)));}
};
 
class Ln : public Func
{
    public:
        int priority() {return 3;}
        double calculate(double x) {return log(right->calculate(x));}
};
 
class Number : public Func
{
    double value;
 
    public:
        Number(double v) {this->value = v;}
        int priority() {return 666;}
        double calculate(double x) {return value;}
};
 
class Name : public Func
{
    std::string value;
    public:
        Name(std::string s) {this->value = s;}
        int priority() {return 666;}
        double calculate(double x) {return x;}
};
 
class Expression
{
    Root *root;
    static uint8_t const functions_count = 3;
    std::string functions_exist[functions_count] = {"sin", "cos", "ln"};
 
    void addNode(Func *root, Func *new_node);
    double getNumber(std::string &, uint16_t &);
    std::string getName(std::string &, uint16_t &);
    bool findFunction(std::string &, Func *root);
    Root *makeTree(std::string &s, uint16_t &curr_pos);
    void deleteTree(Func *node);
 
    public:
        Expression(std::string, uint16_t curr_pos = 0);
        ~Expression() {deleteTree(root);}
 
        double calculate(double);
};
 
#endif // FUNC_TREE_H_INCLUDED
calculator.cpp
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
#include "calculator.h"
 
void Expression::addNode(Func *root, Func *new_node)
{
    while (root->right && (root->right->priority() < new_node->priority()))
    {
        root = root->right;
    }
    new_node->left = root->right;
    root->right = new_node;
}
 
double Expression::getNumber(std::string &s, uint16_t &curr_pos)
{
    double result = 0;
 
    char c = s[curr_pos++];
    while ((c>='0') && (c<='9'))
    {
        result *= 10;
        result += (c - '0');
        if (curr_pos == s.length())
        {
            return result;
        }
        c = s[curr_pos++];
    }
 
    if (c == '.')
    {
        double decimal = 0;
        c = s[curr_pos++];
        while ((c>='0') && (c<='9'))
        {
            decimal += (c - '0');
            decimal /= 10.0;
            if (curr_pos == s.length())
            {
                return result;
            }
            c = s[curr_pos++];
        }
 
        result += decimal;
    }
    curr_pos--;
 
    return result;
}
 
Expression::Expression(std::string s, uint16_t curr_pos)
{
    root = makeTree(s, curr_pos);
}
 
std::string Expression::getName(std::string &s, uint16_t &curr_pos)
{
    std::string result;
    char c = s[curr_pos++];
    bool end_str = false;
 
    while (isalpha(c))
    {
        result += c;
        if (curr_pos == s.length())
        {
            end_str = true;
            break;
        }
        c = s[curr_pos++];
    }
    if (!end_str)
    {
        curr_pos--;
    }
 
    return result;
}
 
bool Expression::findFunction(std::string &s, Func *root)
{
    uint8_t i;
    for (i = 0; i<functions_count; i++)
    {
        if (functions_exist[i] == s)
        {
            break;
        }
    }
 
    switch (i)
    {
        case 0:
        {
            Sinus *sinus = new Sinus();
            addNode(root, sinus);
            break;
        }
 
        case 1:
        {
            Cosinus *cosinus = new Cosinus();
            addNode(root, cosinus);
            break;
        }
 
        case 2:
        {
            Ln *ln = new Ln();
            addNode(root, ln);
            break;
        }
 
        default:
        {
            return false;
        }
    }
 
    return true;
}
 
Root * Expression::makeTree(std::string &s, uint16_t &curr_pos)
{
    Root *root = new Root();
 
    while (curr_pos < s.length())
    {
        char c = s[curr_pos++];
        switch (c)
        {
            case '+':
            {
                Add *add = new Add();
                addNode(root, add);
                break;
            }
 
            case '-':
            {
                Sub *sub = new Sub();
                addNode(root, sub);
                break;
            }
 
            case '*':
            {
                Mul *mul = new Mul();
                addNode(root, mul);
                break;
            }
 
            case '/':
            {
                Div *div = new Div();
                addNode(root, div);
                break;
            }
 
            case '^':
            {
                Power *power = new Power();
                addNode(root, power);
                break;
            }
 
            case '\\':
            {
                Sqrt *sqrt = new Sqrt();
                addNode(root, sqrt);
                break;
            }
 
            case '(':
            {
                Root *tmp = makeTree(s, curr_pos);
                addNode(root, tmp);
                break;
            }
 
            case ')':
            {
                return root;
            }
 
            case ',':
            {
                s.erase(--curr_pos, 1);
                s.insert(curr_pos, ")(");
                break;
            }
 
            default:
            {
                if ((c>='0') && (c<='9'))
                {
                    curr_pos--;
                    Number *number = new Number(getNumber(s, curr_pos));
                    addNode(root, number);
                    break;
                }
                if (c == ' ')
                {
                    break;
                }
 
                curr_pos--;
                std::string tmp = getName(s, curr_pos);
                if (!findFunction(tmp, root))
                {
                    Name *name = new Name(tmp);
                    addNode(root, name);
                }
                break;
            }
        }
    }
 
    return root;
}
 
void Expression::deleteTree(Func *node)
{
    if (node->right != nullptr)
    {
        deleteTree(node->right);
    }
    if (node->left != nullptr)
    {
        deleteTree(node->left);
    }
 
    delete node;
}
 
double Expression::calculate(double x)
{
    return root->calculate(x);
}
Все прекрасно работает в CodeBlocks, а вот Borland C++ Builder 6 ругается чуть менее чем на все. Я так понимаю это из-за того, что он (его компилятор) поддерживает более ранний стандарт?
 
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2017, vBulletin Solutions, Inc.
Рейтинг@Mail.ru