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

Дерево разбора - C++

Войти
Регистрация
Восстановить пароль
Другие темы раздела
C++ что-то не так http://www.cyberforum.ru/cpp-beginners/thread255764.html
в кои-то веки добился того что компилятор c-free не ругается на мой модуль.но использовать там я его не могу. решил запустить на visual studio. создал новый проект,в него отправил код из основной...
C++ считывание строки. С++ Строка считывается посимвольно буквами. а надо, чтобы словами.. как это сделать? FILE *fp2 = fopen("V.txt", "rb"); //открываем файл "dictionary.txt" fseek(fp2, 0, SEEK_END); ... http://www.cyberforum.ru/cpp-beginners/thread255758.html
Какое исключение возникает при невозможности открыть файл? C++
какое исключение отвечает за отсутствие файла?за невозможность открыть файл? FileNotFoundException?
Конструктор класса C++
Имеется: class block{ public: block(int, int); private: int CoordX; int CoordY; }; block::block(int X, int Y){ CoordX = X;
C++ Отсортировать методом выбора элементы тех строк матрицы, которые содержат символ "/" http://www.cyberforum.ru/cpp-beginners/thread255742.html
помогите пожалуйста сделать задачку: разработать приложение выполняющее след. функции:ввести с клавы значение элементов символьного двумерного массива , отсортировать по возростанию методом выбора...
C++ подскажите криворукому как правильно использовать команду ToolsAPI (библиотека для вызова, процесс, на который она ориентируется и т.д.; с примером, если не затруднит) и какой аналог для команды delay в С++ (опять же с... подробнее

Показать сообщение отдельно
ForEveR
В астрале
Эксперт С++
7979 / 4738 / 321
Регистрация: 24.06.2010
Сообщений: 10,543
Завершенные тесты: 3
14.03.2011, 03:26  [ТС]
Разобрал проект на файлы + разбил нормально функции по классам, чтобы было удобнее разбираться впоследствии.
Код под катом.

Tree.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
#include <iostream>
 
#ifndef _TREE_GUARD_
#define _TREE_GUARD_
 
template<class T>
class Tree
{
protected:
      struct Node
      {
    Node(T elem_):elem(elem_), _left(0), _right(0)
    {
    }
    Node* _left;
    Node* _right;
    T elem;
 
             void in_order_print_helper(std::ostream& os)
             {
         if(_left)
        _left->in_order_print_helper(os);
        os<<elem<<'\n';
         if(_right)
        _right->in_order_print_helper(os);
    }
 
    void delete_helper()
    {
        if(_left)
           _left->delete_helper();
        if(_right)
           _right->delete_helper();
           delete this;
    }
 
             void insert_helper(T val)
             {
                 if(val <= elem && left)
                    _left->insert_helper(val);
                 else if(val <= elem && !left)
                    _left=new Node(val);
                 else if(val > elem && right)
                    _right->insert_helper(val);
                 else
                    _right=new Node(val);
              }
};
public:
    Tree():curr(0)
    {
    }
   ~Tree()
   {
    curr->delete_helper();
    }
    void print_in_order(std::ostream& os)
    {
    curr->in_order_print_helper(os);
    }
    void insert(T val)
    {
        !curr ? curr=new Node(val) : curr->insert_helper(val);
    }
protected:
    Node* curr;
};
 
#endif /*_TREE_GUARD_*/


Token.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
#include <string>
#include <utility>
 
#ifndef _TOKEN_GUARD_
#define _TOKEN_GUARD_
 
class Token
{
public:
       enum Type {add='+', multi='*', sub='-', div='/',
        number='8', No};
        Token(Type type_=No, double t_=0.0):
          type(type_), t(t_)
        {
        }
        const Type GetKind() const
        {
            return type;
        }
        const double GetNumb() const
        {
            return t;
        }
 
        friend std::ostream& operator <<(std::ostream&, const Token&);
private:
        double t;
        Type type;
};
 
class Parser
{
public:
        static bool lays_check(const std::string& str);
        static std::string::iterator find_first_in_brakes_helper
            (std::string& some, const char symb);
        static std::pair<std::pair<std::string, std::string>, bool> find_first_in_brakes
            (std::string& some, const char symb);
        static std::string::const_iterator find_first_without_brakes_helper
            (const std::string& some, const char symb);
        static std::pair<std::pair<std::string,std::string>, bool> find_first_without_brakes
            (const std::string& some, const char symb);
};
 
class For_calc
{
public:
    static bool isNumeric(const std::string& some);
    static double toDouble(const std::string& some);
};
 
#endif /*_TOKEN_GUARD_*/


Token.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
#include "Token.h"
#include "Tree.h"
 
#include <sstream>
#include <algorithm>
#include <stack>
 
std::ostream& operator <<(std::ostream& os, const Token& tok)
{
    if(tok.GetKind() != Token::number)
        os<<static_cast<char>(tok.GetKind());
    else
        os<<tok.GetNumb();
    return os;
}
 
bool For_calc::isNumeric(const std::string& some)
{
        double one=0;
        std::stringstream ss(some);
        ss >> one;
        std::stringstream ss2;
        ss2<<one;
        return (one && some.find_first_not_of(ss2.str()) == std::string::npos); 
}
 
double For_calc::toDouble(const std::string& some)
{
    double one;
    std::stringstream ss(some);
    ss>>one;
    return one;
}
 
std::string::iterator 
Parser::find_first_in_brakes_helper(std::string& some, const char symb)
{
        std::string::iterator iter;
        size_t idx=0;
        if(*some.begin() == '(' && *(some.begin()+1) == '(')
                iter=std::find(some.rbegin(), some.rend(), symb).base();
        else
                iter=std::find(some.begin(), some.end(), symb);
        if(iter != some.end())
        {
                some.erase(std::find(some.begin(), some.end(), '('));
                some.erase(std::find(some.begin(), some.end(), ')'));
                iter-=1;
        }
        return iter;
}
 
std::pair<std::pair<std::string, std::string>, bool> 
Parser::find_first_in_brakes(std::string& some, const char symb)
{
        if(For_calc::isNumeric(some))
                return std::make_pair(std::make_pair(some, ""), true);
        std::string::iterator iter=find_first_in_brakes_helper(some, symb);
        if(iter == some.end())
                return std::make_pair(std::make_pair("",""), false);
        std::string begin;
        begin.assign(some.begin(), ++iter);
        std::string end;
        end.assign(iter, some.end());
        return std::make_pair(std::make_pair(begin, end), true);
}
 
std::string::const_iterator 
Parser::find_first_without_brakes_helper
    (const std::string& some, const char symb)
{
        std::stack<char> lays;
        for(std::string::const_iterator iter=some.begin(); iter != some.end(); ++iter)
        {
                if(*iter == '(')
                        lays.push(*iter);
                else if(*iter == ')')
                        lays.pop();
                if(lays.empty() && *iter == symb)
                {
                        return iter;
                }
        }
        return some.end();
}
 
std::pair<std::pair<std::string,std::string>, bool> 
Parser::find_first_without_brakes
    (const std::string& some, const char symb)
{
        if(For_calc::isNumeric(some))
                return std::make_pair(std::make_pair(some, ""), true);
        std::string::const_iterator iter=find_first_without_brakes_helper(some, symb);
        if(iter == some.end())
                return std::make_pair(std::make_pair("", ""), false);
        std::string res;
        res.assign(some.begin(), ++iter);
        std::string end;
        end.assign(iter, some.end());
        return std::make_pair(std::make_pair(res, end), true);
}
 
bool Parser::lays_check(const std::string& str)
{
        std::stack<char> stck;
        for(std::string::const_iterator iter=str.begin(); iter != str.end(); ++iter)
        {
                if(*iter == '(')
                        stck.push(*iter);
                else if(*iter == ')')
                        stck.pop();
        }
        return stck.empty();
}


Sem_Tree.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
#include <string>
 
#include "Tree.h"
#include "Token.h"
 
#ifndef _SEM_TREE_GUARD_
#define _SEM_TREE_GUARD_
 
class Sem_Tree:protected Tree<Token>
{
public:
    Sem_Tree():Tree()
    {
    }
    void create_tree(std::string& str)
    {
        create_tree(str, &curr);
    }
    double count()
    {
       return count_helper(curr);
    }
    void print(std::ostream& os)
    {
        print_in_order(os);
    }
private:
    void create_tree(std::string& str, Node** tree_node);
    template<class Function>
    std::pair<std::string, std::string> 
        create_tree_helper(std::string& str, Node** tree_node,
        TernaryFunction foo);
    double count_helper(Node* tree_node);
};
 
#endif /*_SEM_TREE_GUARD_*/


Sem_Tree.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
#include "Sem_Tree.h"
 
template<class Function>
std::pair<std::string, std::string> 
Sem_Tree::create_tree_helper(std::string &str, Sem_Tree::Node** tree_node, Function foo)
{
        const std::string opers="+-*/";
        bool state=false;
        std::string left;
        std::string right;
        for(std::string::const_iterator iter=opers.begin(); iter != opers.end(); ++iter)
        {
        std::pair<std::pair<std::string, std::string>, bool> pair;
        pair=foo(str, *iter);
        if(pair.second == true)
        {
                left=pair.first.first;
                right=pair.first.second;
                char c='\n';
                if(opers.find(left[left.size()-1]) != std::string::npos && !left.empty())
                {
                        c=left[left.size()-1];
               *tree_node=new Tree<Token>::Node(Token(static_cast<Token::Type>(c), 0));
                        left.resize(left.size()-1);
                }
                std::cout<<c<<'\n'<<left<<'\n'<<right<<'\n';
                std::cout<<'\n';
                if(For_calc::isNumeric(left))
       {
                    (*tree_node)->_left=new Tree<Token>::Node(Token(Token::number, For_calc::toDouble(left)));
           left.clear();
       }
                if(For_calc::isNumeric(right))
       {
                    (*tree_node)->_right=new Tree<Token>::Node(Token(Token::number, For_calc::toDouble(right)));
                    right.clear();
       }
                state=true;
                break;
        }
        else
                continue;
        }
        return std::make_pair(left, right);
}
 
void Sem_Tree::create_tree(std::string& str, Sem_Tree::Node** tree_node)
{
        if(!Parser::lays_check(str))
                throw std::runtime_error("Expression is incorrect");
        std::string left;
        std::string right;
        std::pair<std::string, std::string> left_right=create_tree_helper(str, tree_node,
            Parser::find_first_without_brakes);
        if(left_right.first.empty() && left_right.second.empty() && str.find('(') != std::string::npos)
            left_right=create_tree_helper(str, tree_node, Parser::find_first_in_brakes);
        left=left_right.first;
        right=left_right.second;
        if(!left.empty())
            create_tree(left, &(*tree_node)->_left);
        if(!right.empty())
            create_tree(right, &(*tree_node)->_right);
}
 
double Sem_Tree::count_helper(Node *tree_node)
{
    double val=0.0;
    switch(tree_node->elem.GetKind())
    {
    case Token::add:
        {
            val=count_helper(tree_node->_left) +
                 count_helper(tree_node->_right);
        }
        break;
    case Token::sub:
        {
            val=count_helper(tree_node->_left) -
                 count_helper(tree_node->_right);
        }
        break;
    case Token::multi:
        {
            val=count_helper(tree_node->_left) *
                 count_helper(tree_node->_right);
        }
        break;
    case Token::div:
        {
            val=count_helper(tree_node->_left) /
                 count_helper(tree_node->_right);
        }
        break;
    case Token::number:
        {
            val=tree_node->elem.GetNumb();
        }
        break;
    default:
        throw std::runtime_error("Unexpected token");
    }
    return val;
}
2
 
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2017, vBulletin Solutions, Inc.
Рейтинг@Mail.ru