Форум программистов, компьютерный форум, киберфорум
Наши страницы

С++ для начинающих

Войти
Регистрация
Восстановить пароль
 
 
Мизантроп_Лол
13 / 13 / 2
Регистрация: 26.02.2013
Сообщений: 285
Завершенные тесты: 1
#1

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

05.07.2015, 18:27. Просмотров 1269. Ответов 19
Метки нет (Все метки)

Здравствуйте уважаемые товарищи форумчане. Я пишу интерпретатор математических выражений и, собственно, для этого, сначала перевожу выражение в обратную польскую нотацию. Уже было вроде как закончил и хотел проверить работоспособность перевода, однако CodeBlocks посчитал иначе. Приложение запускается, однако в консоль вылетает ошибка и все. Приложение виснет. Я хотел пройтись пошагово, однако это нечто вылетает сразу же при старте. Ошибку можно увидеть на скриншоте. Исходники:
parser.h
C++
1
2
3
4
5
6
7
8
9
#ifndef PARSER_H_INCLUDED
#define PARSER_H_INCLUDED
 
namespace Parser
{
    std::string toPolish(std::string s);
}
 
#endif // PARSER_H_INCLUDED
parser.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
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
#include <string>
#include <map>
#include <stdio.h>
#include "errors.h"
#include "parser.h"
 
namespace __Stack
{
    struct Stack
    {
        std::string value;
        Stack *next;
    };
 
    Stack *tail = NULL;
 
    void        push(std::string);
    std::string pop();
    void        clear();
}
 
void __Stack::push(std::string value)
{
    Stack *stk = new Stack();
 
    stk->value = value;
    stk->next = tail;
 
    tail = stk;
}
 
std::string __Stack::pop()
{
    std::string result = tail->value;
    Stack *stk = tail;
 
    tail = tail->next;
    delete stk;
 
    return result;
}
 
void __Stack::clear()
{
    Stack *stk;
 
    while (tail)
    {
        stk = tail;
        tail = tail->next;
        delete stk;
    }
}
 
///////////////////////////////////////////////////////////////////
 
namespace __Parser
{
    enum eTokens
    {
        NAME,           NUMBER,          FUNC,      U_MINUS,
        PLUS = '+',     MINUS = '-',     MUL = '*', DIV = '/',
        POW  = '^',     SQRT  = '\\',
        L_BRUNCH = '(', R_BRUNCH = ')'
    };
 
    eTokens curr_token;
    uint16_t char_pos = 0;
    //Используется для определения, является знак '+' или '-'
    //унарным или бинарным.
    //Если это начало выражения или перед текущим знаком была бинарная
    //операция или открывающая скобка - знак унарный.
    bool sign = true;
    //Имя переменной
    std::string x_name;
    std::string functions = {"sin", "cos"};
    std::map<eTokens, int> token_priority = {{L_BRUNCH, 0},
                                             {R_BRUNCH, 0},
                                             {PLUS,     1},
                                             {MINUS,    1},
                                             {MUL,      2},
                                             {DIV,      2},
                                             {POW,      3},
                                             {SQRT,     3},
                                             {U_MINUS,  4},
                                             {FUNC,     5}};
    const int funcs_count = 2;
 
    inline char getChar(std::string &);
    inline void backChar();
    bool        isFunc(std::string &);
    std::string getNumber(std::string &);
    std::string getName(std::string &);
    std::string getToken(std::string &);
    std::string pop();
    void        deleteSpaces(std::string);
    std::string toPolish(std::string &);
}
 
char __Parser::getChar(std::string &s)
{
    return s[char_pos++];
}
 
void __Parser::backChar()
{
    char_pos--;
}
 
bool __Parser::isFunc(std::string &s)
{
    for (int i = 0; i<funcs_count; i++)
    {
        if (s.find(functions[i]))
        {
            return true;
        }
    }
    return false;
}
 
std::string __Parser::getNumber(std::string &s)
{
    std::string result;
    char c = getChar(s);
 
    while ((c>'0') && (c<'9'))
    {
        result += c;
        if (char_pos == s.length() - 1)
        {
            return result;
        }
        c = getChar(s);
    }
    backChar();
 
    return result;
}
 
std::string __Parser::getName(std::string &s)
{
    std::string result;
    char c = getChar(s);
    bool end_str = false;
 
    while (isalpha(c))
    {
        result += c;
        if (char_pos == s.length() - 1)
        {
            end_str = true;
            break;
        }
        c = getChar(s);
    }
    if (!end_str)
    {
        backChar();
    }
 
    if (isFunc(result))
    {
        curr_token = FUNC;
    }
    else
    {
        curr_token = NAME;
        if (x_name.empty())
        {
            x_name = result;
        }
        else
        {
            throw Error("ошибка: неверное имя переменной", char_pos - result.length());
        }
    }
 
    return result;
}
 
std::string __Parser::getToken(std::string &s)
{
    char c = getChar(s);
 
    switch (c)
    {
        case '+': case '-':  case '*': case '/':
        case '^': case '\\': case '(': case ')':
            curr_token = (eTokens)c;
            std::string result;
            result += c;
            return result;
    }
 
    if ((c>'0') && (c<'9'))
    {
        backChar();
        curr_token = NUMBER;
        return getNumber(s);
    }
 
    return getName(s);
}
 
std::string __Parser::pop()
{
    std::string result = __Stack::pop();
    return getToken(result);
}
 
void __Parser::deleteSpaces(std::string s)
{
    for (uint16_t i = 0; i<s.length(); i++)
    {
        if (s[i] == ' ')
        {
            s.erase(i, 1);
        }
    }
}
 
std::string __Parser::toPolish(std::string &s)
{
    char_pos = 0;
    sign = true;
 
    int last = s.length() - 1;
    std::string result;
    std::string token_value;
    __Stack::clear();
 
    using __Stack::push;
    while (char_pos != last)
    {
        token_value = getToken(s);
        switch (curr_token)
        {
            case NUMBER:
            {
                sign = false;
                result += token_value + " ";
                break;
            }
 
            case L_BRUNCH:
            {
                sign = true;
                push(token_value);
                break;
            }
 
            case R_BRUNCH:
            {
                sign = false;
                while (true)
                {
                    token_value = pop();
                    if (curr_token == L_BRUNCH)
                    {
                        break;
                    }
                    result += token_value + " ";
                }
                break;
            }
 
            case PLUS:{} case MINUS:{} case MUL:{}
            case DIV:{}  case POW:{}   case SQRT:{}
            case FUNC:
            {
                if (curr_token == MINUS)
                {
                    if (sign)
                    {
                        curr_token = U_MINUS;
                    }
                }
                sign = false;
                eTokens tok = curr_token;
                std::string buff;
                while (true)
                {
                    buff = pop();
                    if (token_priority[curr_token]>=token_priority[tok])
                    {
                        result += buff + " ";
                    }
                    else
                    {
                        break;
                    }
                }
                push(buff);
                push(token_value);
                break;
            }
 
            case NAME:
            {
                sign = false;
                result += token_value + " ";
                break;
            }
 
            default:
            {
                throw Error("ошибка: неизвестный токен", char_pos);
                break;
            }
        }
    }
 
    return result;
}
 
std::string Parser::toPolish(std::string s)
{
    __Parser::deleteSpaces(s);
    return __Parser::toPolish(s);
}
main.cpp
C++
1
2
3
4
5
6
7
8
9
10
#include <iostream>
#include <string>
#include "parser.h"
 
using namespace std;
 
int main()
{
    cout << Parser::toPolish("x + 2");
}
P.S.
Еще хотел бы попросить, если не сложно, оценить код, может что-то посоветовать, за что-то наругать, за что-то кинуть тапком и т.д. А то мало ли.
P.P.S.
Обработка ошибок пока что только в зародыше, поэтому на нее не смотрите.

Благодарю за внимание.
0
Миниатюры
Парсер для математических выражений  
Надоела реклама? Зарегистрируйтесь и она исчезнет полностью.
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
05.07.2015, 18:27
Здравствуйте! Я подобрал для вас темы с ответами на вопрос Парсер для математических выражений (C++):

Написать парсер математических выражений с функцией упрощения этих выражений - C++
Люди, здравствуйте. Есть такая задача: написать упроститель выражений. На вход подается строка вида &quot;a*b+a*c&quot;, являющаяся корректным...

Парсер математических выражений - C++
знаю изъезженная тема, надо написать парсер мат выражений с поддержкой скобок и некоторых несложных функций типа: sin, cos, tg, ctg, ln......

Парсер математических выражений на С/С++ - C++
Добрый вечер, можете написать или помочь написать парсер математических выражений для программы вычисляющей интеграл

Парсер математических выражений - можно ли оптимизировать и улучшить код - C++
Добрый день возник следующий вопрос, в программировании не сильно большой гуру пошел на собеседование , дали тестовое задание парсер...

Парсер математических выражений на с++ визуал студио 2013 в windows forms перевести в обратную пз - C++
нужно сделать парсер перевести в обратную польскую запись затем посчитать в окне

Вычисление математических выражений - C++
Всем привет, я пишу этот пост в связи с тем что, мне дали это задание не обьяснив как её правильно написать. Я учусь на данный момент на...

19
Fulcrum_013
699 / 764 / 74
Регистрация: 14.12.2014
Сообщений: 6,036
Завершенные тесты: 3
05.07.2015, 21:32 #16
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
AnsiString DeleteUnusableBarsets(AnsiString Function) {
    AnsiString Temp = Function;
    do {
        if (Temp[1] != '(' || Temp[Temp.Length()] != ')')
            return Temp;
        int BarsetCount = 0;
        bool BarsetExist = false;
        for (int i = 1; i < Temp.Length() - 1; i++)
            if (Temp[i] == '(') {
                BarsetCount++;
                BarsetExist = true;
            }
            else if (Temp[i] == ')') {
                BarsetCount--;
                if (!BarsetCount && BarsetExist)
                    return Temp;
            }
        Temp = Temp.SubString(2, Temp.Length() - 2);
    }
    while (1);
}
 
TDelimeterType __fastcall FindDelimeter(AnsiString Function, int *OperationType,
    int *Start, int *End) {
    *OperationType = otNone;
    for (int i = 0; i < 12; i++) {
        int BarsetCount = 0;
        for (int j = 1; j <= Function.Length(); j++)
            if (Function[j] == '(')
                BarsetCount++;
            else if (Function[j] == ')')
                BarsetCount--;
            else if (Function[j] == Delimeters[i] && !BarsetCount) {
                *Start = j - 1;
                *OperationType = i + 1;
                *End = j + 1;
                return dtBinarOperation;
            }
    }
    for (int i = 0; i < 10; i++)
        if (Function.AnsiPos(FunctionNames[i] + "(") == 1) {
            *Start = 1;
            *OperationType = i + otSin;
            *End = FunctionNames[i].Length();
            return dtUnarOperation;
        }
    return dtNone;
}
 
TTreeElement* __fastcall CreateTree(AnsiString aFunction, double **Variables) {
    if (!aFunction.Length())
        return NULL;
    AnsiString Function = aFunction.UpperCase();
    Function = DeleteUnusableBarsets(Function);
    int Start, End, Temp;
    int OperationType;
    TTreeElement *ret;
    switch (FindDelimeter(Function, &OperationType, &Start, &End)) {
    case dtNone:
        if ((Temp = CheckVariable(Function)) > -1)
            return new TVariable(Variables, Temp);
        else if ((Temp = CheckConstant(Function)) > -1)
            return new TConstant(Constants[Temp]);
        else {
            return new TConstant(StrToFloat(Function));
        }
    case dtBinarOperation: {
            AnsiString t1 = Function.SubString(1, Start);
            AnsiString t2 =
                Function.SubString(End, Function.Length() - End + 2);
            switch (OperationType) {
            case otLet:
                if ((Temp = CheckVariable(t1)) > -1) {
                    ret = new TLet(Variables, Temp);
                    ret->LeftNode = CreateTree(t2, Variables);
                    ret->RightNode = NULL;
                    return ret;
                }
                else
                    throw Exception("Unknown identifier '" + t1 + "'");
            case otOr:
                ret = new TOr();
                break;
            case otAnd:
                ret = new TAnd();
                break;
            case otAbove:
                ret = new TAbove();
                break;
            case otBelow:
                ret = new TBelow();
                break;
            case otEqual:
                ret = new TEqual();
                break;
            case otAdd:
                ret = new TAddition();
                break;
            case otSub:
                ret = new TSubstraction();
                break;
            case otMul:
                ret = new TMultiplection();
                break;
            case otDiv:
                ret = new TDivision();
                break;
            case otPow:
                ret = new TPow();
                break;
            case otRoot:
                ret = new TRoot();
                break;
            }
            ret->LeftNode = CreateTree(t1, Variables);
            ret->RightNode = CreateTree(t2, Variables);
            return ret;
        }
    case dtUnarOperation: {
            TFunction *ret1 = new TFunction();
            AnsiString t1 = Function.SubString(End + 1,
                Function.Length() - End);
            switch (OperationType) {
            case otSin:
                ret1->OnCalc = sin;
                break;
            case otCos:
                ret1->OnCalc = cos;
                break;
            case otTg:
                ret1->OnCalc = tan;
                break;
            case otCtg:
                ret1->OnCalc = ctg;
                break;
            case otArcsin:
                ret1->OnCalc = asin;
                break;
            case otArccos:
                ret1->OnCalc = acos;
                break;
            case otArctg:
                ret1->OnCalc = atan;
                break;
            case otArcctg:
                ret1->OnCalc = actg;
                break;
            case otLn:
                ret1->OnCalc = log;
                break;
            case otLog:
                ret1->OnCalc = log10;
                break;
            }
            ret1->LeftNode = CreateTree(t1, Variables);
            ret1->RightNode = NULL;
            return ret1;
        }
    }
 
    return NULL;
}
Примерно вот так. Делалось когда то давно на скорую руку не заботясь о скорости функции FindDelimiter/
0
Мизантроп_Лол
13 / 13 / 2
Регистрация: 26.02.2013
Сообщений: 285
Завершенные тесты: 1
06.07.2015, 16:46  [ТС] #17
Вот что у меня получилось. Может быть кому-нибудь пригодится. Ну а более опытных форумчан, попрошу покритиковать код.

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 ругается чуть менее чем на все. Я так понимаю это из-за того, что он (его компилятор) поддерживает более ранний стандарт?
0
Fulcrum_013
699 / 764 / 74
Регистрация: 14.12.2014
Сообщений: 6,036
Завершенные тесты: 3
06.07.2015, 17:02 #18
из того что в глаза бросается 6-ой билдер будет на nullptr ругаться. и может быть на uint16_t
0
Мизантроп_Лол
13 / 13 / 2
Регистрация: 26.02.2013
Сообщений: 285
Завершенные тесты: 1
06.07.2015, 17:09  [ТС] #19
Fulcrum_013, а моя догадка о причине правильная или тут дело в чем-то другом?

Добавлено через 35 секунд
Fulcrum_013, еще ему не понравилось объявление константы
C++
1
const double TO_RAD_KOEF = 0.017453292519;
0
Fulcrum_013
699 / 764 / 74
Регистрация: 14.12.2014
Сообщений: 6,036
Завершенные тесты: 3
06.07.2015, 17:18 #20
XE6 прожевал без вопросов. Я так понимаю эту константу и Turbo C++ 1.0 без вопросов прожует. может там где то ругань на предыдущую строчку?
0
06.07.2015, 17:18
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
06.07.2015, 17:18
Привет! Вот еще темы с ответами:

Вычисления математических выражений - C++
Это что выделено красным я не понимаю что с меня там хотят посмотрите у меня программе такое есть? &quot;реакцию программы на некорректны...

Программирование математических выражений в C++ - C++
Составить программу для вычисления значения функции F при указанных значениях аргументов и вывода значений аргументов и функций на экран...

Разбор математических выражений - C++
Добрый день, нуждаюсь в вашей помощи. Написал код программы для решения определённого уравнения методом половинного деления. Необходимо...

Анализатор математических выражений - C++
Всем привет. Я начинающий программист, там где я учусь, задали написать анализатор математических выражений. Я посмотрел в яндексе, гугле -...


Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
20
Ответ Создать тему
Опции темы

КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2017, vBulletin Solutions, Inc.
Рейтинг@Mail.ru