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

Очередь с приоритетом - C++

Восстановить пароль Регистрация
 
Catzo
0 / 0 / 0
Регистрация: 09.11.2013
Сообщений: 7
22.05.2014, 11:38     Очередь с приоритетом #1
Здравствуйте! Нужна ваша помощь! Не могу разобраться в чём проблема.
Создаю очередь с приоритетом(шаблонный класс) с типом данных Job. На добавлении в очередь второго элемента программа вылетает. Вылетает на моменте delete (this->data); в методе Add(), в классе QueueWithPriority
C++
1
2
3
                        //Deleting  data and priority
            delete (this->data);
            delete (this->p);
И еще, подскажите(или объясните, если не трудно), где вычитать, что бы мне наконец-то отложилось в голове, чем отличается delete (this->data); от delete [] this->data;
Есть шаблонный класс QueueWithPriority
Кликните здесь для просмотра всего текста
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
template <class Type,class Priority>
class QueueWithPriority
{
private:
    //Data storage
    Type* data;
    //Priority pointer, indexes of elements in Priority and Data are equal
    Priority* p;
    //Index of first free element in queue
    int top;
    //Queue's max size
    int capacity;
 
public:
    //CONSTRUCTORS
    QueueWithPriority(int cap = 1)
    {
        //Capacity of queue can't be less, than 1
        if(cap < 1)
            cap = 1;
        //Initializing capacity
        this->capacity=cap;
        //Allocating mmry for data
        this->data=new Type[this->capacity];
        //Allocating mmry for priority
        this->p=new Priority[this->capacity];
        //Initializing top
        this->top=0;
    }
    //========================================================
    //GETTERS
    //Getting data
    const Type* GetData() const
    {
        return this->data;
    }
    //Getting index of first free element
    int GetTop() const
    {
        return this->top;
    }
    //Getting queue size
    int GetCapacity() const
    {
        return this->capacity;
    }
    //Getting MAX priority (Search method)
    Priority GetPri()
    {
        //Creating temporary object,  where maximal priority value will be written
        Priority max = 0;
        //If queue is empty
        if (this->IsEmpty()) 
            return max;
        //Initialazing max  with first queue's element
        max = this->p[0];
        //Searching cycle
        for(int i = 0; i < this->top; i++) 
            //If p[i] priority higher, than current max priority
            if (this->p[i] > max) 
                max = p[i];
        //Returning max priority
        return max;
 
    }
    //========================================================
 
    //METHODS
    //If queue is FULL, TRUE will be returned
    bool IsFull()
    {
        return this->top==this->capacity;
    }
    //If queue is EMPTY, TRUE will be returned 
    bool IsEmpty()
    {
        return this->top==0;
    }
    //Method, that add obj to queue
    void Add( Type& obj, const Priority& p )
    {
        //If queue is full
        if(IsFull()) 
        {
            //Creating temporary object, with bigger capacity(multiplied by 4)
            QueueWithPriority<Type,Priority> tmp(this->capacity*2);
            //Cycle, that extracts all elements from data and priority, and push them into tmp
            while(this->GetTop()>0)
            {
                //Writing max priority to temporary prioriry storage
                Priority tmppri=this->GetPri();
                //Getting element with max priority
                Type t=this->PopOut();
                //Recursive call
                tmp.Add(t,tmppri);
            }
            //Deleting  data and priority
            delete (this->data);
            delete (this->p);
            //Multiplying capacity of queue
            this->capacity*=2;
            //Assigning new values
            this->data=tmp.data;
            this->p=tmp.p;
            this->top=tmp.top;
        }
        
        this->p[this->top]=p;
        //firstly using old value of top, than increasing it
        this->data[this->top++]=obj;
        
    }
    //Extracting methos
    Type PopOut()
    {
        //If queue is empty
        if ( IsEmpty() )
        {   //Creating new, empty object and returning it
            Type tmp;
            return tmp;
        }
        //Creating temporary varibale, and initialazing it with first queue's element
        Priority max=p[0];
        //variable, that contains max priority index
        int imax=0;
        //Search cycle
        for (int i=0;i<this->top;i++)
        {
            //If p[i] > current max priority
            if (p[i]>max) 
            {
                //Reassigning  max variable
                max=p[i];
                //Reassigning max index variable
                imax=i;
            }
        }
        //Creating temporary storage for element, that will be poped out and returned
        //And saving element with highest priority
        Type tmp=this->data[imax];
        // Elements move cycle
        for(int i=imax;i<this->top-1;i++)
        {
            this->data[i]=this->data[i+1];
            this->p[i]=this->p[i+1];
        }
        //Decrementing top position
        this->top--;
        //Returning extracted element
        return tmp;
 
    }
    //========================================================
    //OPERATORS OVERLOAD
    //Indexation operator overload
    Type operator[] (int index)
    {
        //For cases, when argument's value is less than 0
        if(index < 0) 
            //returning first element
            return this->data[0];
        //When index higher, or equal to top
        else if(index>=this->top)
            //Returning last element
            return this->data[this->top-1];
        else 
            return this->data[index];
    }
    //========================================================
    void Show() 
    {
        if(this->top == 0)
            cout<<"Line is empty, all tasks are printed"<<endl;
        else
        {
            for(int i = 0; i < this->top;i++)
                cout<<this->data[i]<<endl;
        }
    }
    void ExtractFromLine(char Filename[30])
    {
        for(int i = 0; i < 4; i++)
        {
            Job tmp;
            tmp = this->PopOut();
            tmp.WriteToFile(Filename);
        }
    }
};

Есть класс Job
Кликните здесь для просмотра всего текста

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
class Job
{
private:
    //Task counter
    static int id;
    //Task ID
    int task_id;
    //Text storage
    char* data;
    //Print priority
    int priority;
    
public:
    //CONSTRUCTOR               
    Job(char* text="No text")
    {
        //Variable, that contains size of text
        int text_size = strlen(text);
        //Allocating mmry
        this->data = new char[text_size+1];
        //Copying text
        strcpy_s(this->data, text_size+1, text);
        //Incrementing task counter
        this->id++;
        this->task_id=this->id;
        this->priority = 0;
        //Calculating print priority
        this->PriorityCalculation(text_size+1, text);
         
    }
    //Copy constructor
    Job(const Job& obj)
    {
        //Copying id and priority values
        this->id = obj.id;
        this->task_id = obj.task_id;
        this->priority = obj.priority;
        //Write down text size
        int text_size = strlen(obj.data);
        //Allocating mmry
        this->data = new char[text_size+1];
        //Copying text
        strcpy_s(this->data, text_size+1, obj.data);
    }
    //================================================
 
    //DESTRUCTOR
    ~Job()
    {
        cout<<"Destructor is working"<<endl;
        delete [] this->data;
        cout<<"Done"<<endl;
        this->id--;
    }
    //================================================
 
    //SETTERS
    //Setting counter value
    void SetID(int id)
    {
        if(id < 0)
            id = 0;
        this->id = id;
    }
    //Setting text
    void SetText(char* text)
    {
        //If there are no symbols in text
        if(strlen(text) == 0)
            return;
        //Variable, that contains size of text
        int text_size = strlen(text);
        ////deleting data
        delete [] data;
        //Allocating mmry
        this->data = new char[text_size+1];
        //Copying text
        strcpy_s(this->data, text_size+1, text);
        //Calculating new priority
        this->PriorityCalculation(text_size+1,text);
 
    }
    //Setting priority
    void SetPriority(int pri)
    {
        if(pri < 0)
            pri = 0 ;
        this->priority = pri;
    }
    //Setting task ID
    void SetTaskID(int id)
    {
        if(id < 0) 
            id = 0;
        this->task_id = id;
    }
    //================================================
 
    //GETTERS
    //Getting counter value
    int GetID() const
    {
        return this->id;
    }
    //Getting text
    const char* GetData() const
    {
        return this->data;
    }
    //Getting priority
    int GetPriority() const
    {
        return this->priority;
    }
    //Getting task id
    int GetTaskID() const
    {
        return this->task_id;
    }
    //================================================
 
    //OPERATORS OVERLOAD
    Job& operator= (Job& obj)
    {
        //If this and obj are the same objects
        if(this == &obj) 
            //returning this object
            return *this;
        //If there is something in data storage
        if(this->data != NULL) 
            //deleting data
            delete [] data;
 
        //Copying ids and priority values
        this->id = obj.id;
        this->task_id= obj.task_id;
        this->priority = obj.priority;
        //Write down text size
        int text_size = strlen(obj.data);
        //Allocating mmry
        this->data = new char[text_size+1];
        //Copying text
        strcpy_s(this->data, text_size+1, obj.data);
        return *this;
    }
    //================================================
    //METHODS
    //Method, that calculate priority of this object's text
    void PriorityCalculation(int text_size, char* text)
    {
        //Calculating print priority
        for(int i = 0; i < text_size; i++)
        {
            //If result of isdigit() func not ueqal to zero
            if( !isdigit(text[i]))
                //Additing int code of symbol to priority
                this->priority+=(int)text[i];
            else
                //If symbol is digit, than multiplying priority by digit
                this->priority+=(int)text[i]*(text[i] -'0');
                    
        }
    }
    //Method, that write info about printed task to file
    void WriteToFile(char name[30])
    {
        FILE * file;
        //If fopen_s return something else, than zero, there is something wrong
        if( fopen_s(&file, name, "a+b") == 0)
        {
            if(this->data != NULL)
            {
                fprintf_s(file,"\n%s %d\n%s %i\n%s\n %s\n\n ", "Task ID:", this->task_id, "Task Priority:", this->priority, "Printed Text:", this->data);
                fclose(file);
            }
            else 
                return;
        }
        //In case of errors
        else
        {
            cout<<"Oops!I can`t open file "<<name<<"!"<<endl
                <<"Maybe, there is no file?"<<endl;
        }
    }
    //Static method, that read all text from file, and put it onto screen
    static void ReadFromFile(char name[30])
    {
        FILE * file;
        //If fopen_s return something else, than zero, there is something wrong
        if( fopen_s(&file, name, "rb") == 0)
        {
            char s;
            //Cycle is going until function feof() returned result is zero
            while(!feof(file) )
            {
                s=getc(file);
                cout<<s;
            }
        }
        //In case of errors
        else
        {
            cout<<"Oops!I can`t open file "<<name<<"!"<<endl
                <<"Maybe, there is no file?"<<endl;
        }
    }
 
    //================================================
    //OPERATORS OVERLOAD
    // Operator More Than  overload
    bool operator > (Job& obj)
    {
        //If current tasks priority more than received object's priority, TRUE will be returned
        return this->priority > obj.priority;
    }
    // Operator Less Than  overload
    bool operator < (Job& obj)
    {
        //If current tasks priority less than received object's priority, TRUE will be returned
        return this->priority < obj.priority;
    }
};
ostream& operator<<(ostream& os, Job& obj)
{
    os<<"Task ID: "<<obj.GetTaskID()<<endl
        <<"Print priority: "<<obj.GetPriority()<<endl
            <<"Text: "<<obj.GetData()<<endl
            <<"==================="<<endl;
 
    return os;
}
 
int Job::id = 0;

Мой мэйн
Кликните здесь для просмотра всего текста

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
#include "h.h"
#include "QueueWithPriority.h"
void main()
{
    Job task1("A Turing machine is a hypothetical device that manipulates symbols on a strip of tape according to a table of rules.");
    Job task2("Turing gave a succinct definition of the experiment in his 1948 essay, ""Intelligent Machinery"" ");
    Job task3("Usually large TABLES are better left as tables (Booth, p. 74). They are more readily simulated by computer in tabular form (Booth, p. 74).");
    Job task4("Today, the counter, register and random-access machines and their sire the Turing machine continue to be the models of choice for theorists investigating questions in the theory of computation.");
    char FileName[30] = {"Line.txt"};
    
    QueueWithPriority <Job, int> PrintLine;
    PrintLine.Add(task1, task1.GetPriority());
    PrintLine.Add(task2, task2.GetPriority());
    PrintLine.Add(task3, task3.GetPriority());
    PrintLine.Add(task4, task4.GetPriority());
    cout<<"We`ve got "<<PrintLine.GetData()->GetID()<<" tasks, that need to be printed today"<<endl
        <<"Here they are:"<<endl;
    PrintLine.Show();
    cout<<"Press any key to start print"<<endl;
    _getch();
    cout<<"Working..."<<endl;
    PrintLine.ExtractFromLine(FileName);
    Sleep(500);
    cout<<"Print line: "<<endl;
    PrintLine.Show();
    cout<<endl<<"Press any key to see, what have we printed today"<<endl;
    _getch();
    Job::ReadFromFile(FileName);
    
 
}

Очень хочу понять, в чём причина! Заранее благодарю!
Лучшие ответы (1)
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
22.05.2014, 11:38     Очередь с приоритетом
Посмотрите здесь:

Очередь с приоритетом. C++
Очередь с приоритетом C++
Очередь с приоритетом C++
Очередь с приоритетом C++
Очередь с приоритетом C++
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
Croessmah
Модератор
Эксперт С++
 Аватар для Croessmah
11800 / 6779 / 765
Регистрация: 27.09.2012
Сообщений: 16,829
Записей в блоге: 2
Завершенные тесты: 1
22.05.2014, 11:40     Очередь с приоритетом #2
Сообщение было отмечено автором темы, экспертом или модератором как ответ
Во-первых, если выделяли с помощью new[], то и освобождать нужно с помощью delete[]
C++
1
2
            delete [] (this->data);
            delete [] (this->p);
Во-вторых, посмотрим что будет после исправления
Catzo
0 / 0 / 0
Регистрация: 09.11.2013
Сообщений: 7
22.05.2014, 11:51  [ТС]     Очередь с приоритетом #3
А ведь и правда... Исправил, перестало вылетать. Благодарю.
Подскажите, пожалуйста, по поводу вот этих круглых скобок delete [] (this->data);
Croessmah
Модератор
Эксперт С++
 Аватар для Croessmah
11800 / 6779 / 765
Регистрация: 27.09.2012
Сообщений: 16,829
Записей в блоге: 2
Завершенные тесты: 1
22.05.2014, 11:53     Очередь с приоритетом #4
Цитата Сообщение от Catzo Посмотреть сообщение
Подскажите, пожалуйста, по поводу вот этих круглых скобок
а что в них такого? Можете убрать:
C++
1
delete [] this->data;
Catzo
0 / 0 / 0
Регистрация: 09.11.2013
Сообщений: 7
22.05.2014, 11:56  [ТС]     Очередь с приоритетом #5
То есть, разницы между delete [] this->data; и delete [] (this->data); никакой?
Просто сам класс очередь с приоритетом достался мне от одногруппинка, вот сижу и разбираю код,попутно пишу комментарии и на этом моменте встал в ступор, ведь гугл ответа не дает.
Yandex
Объявления
22.05.2014, 11:56     Очередь с приоритетом
Ответ Создать тему
Опции темы

Текущее время: 07:43. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2016, vBulletin Solutions, Inc.
Рейтинг@Mail.ru