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

освобождение памяти - C++

Восстановить пароль Регистрация
 
Why so seriouS
 Аватар для Why so seriouS
44 / 44 / 1
Регистрация: 12.03.2013
Сообщений: 167
24.03.2013, 18:26     освобождение памяти #1
Помогите найти ошибку, программа вилиться когда освобождаю память!
Здесь выделения памяти
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
double **CreateArray()
{
    double **pmatrix;
    int k,j;
    double delta;
 
    pmatrix = new double*[nrows];
    if(!pmatrix){
        cerr<<"Error!";
        return NULL;
    }
    
    for(k=0;k<nrows;++k){
        pmatrix[k] = new double[ncolms];
 
        if(pmatrix[k] == NULL){
            DeleteArray(pmatrix,k);
            return NULL;
        }
 
        for(j = 0;j < ncolms; ++j){
            delta = static_cast<double>(j+1) / ncolms;
            pmatrix[k][j] = EnergyAlphaParticle(delta);
        }
    }
    return pmatrix;
}
Здесь освобождаю память:
C++
1
2
3
4
5
6
7
8
9
void DeleteArray(double **pmatrix, int rows)
{
    double **prow;
    
    for(prow = pmatrix; prow < pmatrix + rows; ++prow)
        delete [] (*prow);
    
    delete [] pmatrix;
}
Кликните здесь для просмотра всего текста
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
#include <iostream>
#include <math.h>
#include <time.h>
#include <stdio.h>
#include <fstream>
#include <cstdlib>
 
using namespace std;
 
void InputDimenstion();
double** CreateArray();
void PrintMatrix(char* info,double *matr[],int print_sum);
void SortRows(double**matr);
void WriteMatrix(double *pmatrix[]);
void WriteSum(double *pmatrix[]);
void DeleteArray(double**matr,int rdel);
double EnergyAlphaParticle(double);
double ParticleCharge();
 
const double H = 1;
const double Q = 1e4;
const double Epsilon = 1e-4;
const double Alpha = 1e-9;
const double PI = 3.1415926;
const double Z = 1;
const double R1 = 0.1;
const double Beta = 1e-3;
 
const int RAND_INT = 10;
 
const char fn_matrix[] =  "matrix.txt";
const char fn_sum[] =  "sum.txt";
 
int nrows, ncolms;
 
int main()
{
    double **parray;
    InputDimenstion();
    parray = CreateArray();
    if(parray == NULL)
        return 1;
 
    PrintMatrix("Matrix energy:",parray,false);
    WriteMatrix(parray);
 
    SortRows(parray);
    PrintMatrix("Sort matrix:",parray,true);
    WriteSum(parray);
 
    //DeleteArray(parray,nrows);
    
    system("pause>0");
    return 0;
}
 
void InputDimenstion()
{
    cout<<"Matrix dimension[MxN] - ";
    cin>>nrows>>ncolms;
}
 
double **CreateArray()
{
    double **pmatrix;
    int k,j;
    double delta;
 
    pmatrix = new double*[nrows];
    if(!pmatrix){
        cerr<<"Error!";
        return NULL;
    }
    
    for(k=0;k<nrows;++k){
        pmatrix[k] = new double[ncolms];
 
        if(pmatrix[k] == NULL){
            DeleteArray(pmatrix,k);
            return NULL;
        }
 
        for(j = 0;j < ncolms; ++j){
            delta = static_cast<double>(j+1) / ncolms;
            pmatrix[k][j] = EnergyAlphaParticle(delta);
        }
    }
    return pmatrix;
}
 
void PrintMatrix(char* info,double *pmatrix[],int print_sum)
{
    double **prow, *pnode;
    int k,j;
 
    cout<<info<<endl;
 
    for(k = 0, prow = pmatrix; k < nrows; ++k, ++prow,cout<<endl){
        for(j = 0, pnode = *prow; j < ncolms; ++j, ++pnode){
            cout<<(*pnode)<<" ";
        }
        if(print_sum)
            cout<<(*(*prow + ncolms))<<" ";
    }
}
 
void WriteMatrix(double *pmatrix[])
{
    double **prow, *pnode;
    int k,j;
 
    ofstream f1("matrix.txt",ios::in);
    
    if(!f1){
        cerr<<"Cant open file!!!"<<endl;
        return;
    }
    for(k = 0, prow = pmatrix;k < nrows; ++k, ++prow){
        for(j = 0,  pnode = *prow; j < ncolms ; ++j, ++pnode){
            f1 << (*pnode);
        }
        f1 << endl;
    }
    f1.close();
}
 
void WriteSum(double *pmatrix[])
{
    double **prow;
    int k;
 
    ofstream f1(fn_sum,ios::in);
    if(!f1){
        cerr<<"Cant open file!!!"<<endl;
        return;
    }
    for(k = 0, prow = pmatrix; k < nrows; ++k, ++prow){
        f1 << (*(*prow + ncolms)) << " ";
    }
    f1.close();
}
 
void SortRows(double **pmatrix)
{
    double **prow, **prow2;
    double *pcell, *psum;
    double *tmp;
 
    for(prow = pmatrix; prow < pmatrix + nrows; ++prow)
        for(pcell = *prow, psum = *prow + ncolms; pcell < psum; ++pcell)
            *psum += *pcell;
 
    for(prow = pmatrix; prow < pmatrix + nrows - 1; ++prow)
        for(prow2 = prow + 1; prow2 < pmatrix + nrows; ++prow2){
            if((*prow)[ncolms] > (*prow2)[ncolms]){
                tmp = *prow;
                *prow = *prow2;
                *prow2 = tmp;
            }
        }
}
 
void DeleteArray(double **pmatrix, int rows)
{
    double **prow;
    
    for(prow = pmatrix; prow < pmatrix + rows; ++prow)
        delete [] (*prow);
    
    delete [] pmatrix;
}
 
double EnergyAlphaParticle(double Z)
{
    double W;
    double charge = ParticleCharge();
 
    W = charge * Q / (2 * PI * Epsilon * H) * log(Z / R1);
 
    return W;
}
 
double ParticleCharge()
{
    double charge;
    double factor = rand();
 
    charge = (Beta * factor) * Alpha;
 
    return charge;
}


Добавлено через 2 часа 27 минут
up.
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
24.03.2013, 18:26     освобождение памяти
Посмотрите здесь:

C++ Освобождение памяти
резервирование памяти/освобождение памяти для трехмерного массива C++
Освобождение памяти C++
с++ Освобождение памяти C++
C++ Освобождение памяти
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
yoghurt92
373 / 344 / 22
Регистрация: 17.05.2012
Сообщений: 1,049
24.03.2013, 18:35     освобождение памяти #2
Why so seriouS, попробуй так

C++
1
2
3
4
5
6
7
void DeleteArray(double **pmatrix, int /*кол-во столбцов*/)
{
    for(int i = 0; i < /*кол-во столбцов*/; ++i)
        delete [] pmatrix[i];
    
    delete [] pmatrix;
}
go
Эксперт C++
3582 / 1362 / 128
Регистрация: 16.04.2009
Сообщений: 4,528
24.03.2013, 18:47     освобождение памяти #3
Цитата Сообщение от Why so seriouS Посмотреть сообщение
Помогите найти ошибку, программа вилиться когда освобождаю память!
Пройдитесь дебагом, или дайте больше информации. Вроде как все ок. Есть подозрение, что она здесь не причем.

Добавлено через 1 минуту
Цитата Сообщение от yoghurt92 Посмотреть сообщение
попробуй так
по строкам идти надо. Выход за пределы памяти схватите.
yoghurt92
373 / 344 / 22
Регистрация: 17.05.2012
Сообщений: 1,049
24.03.2013, 18:48     освобождение памяти #4
go, точно, тупонул
Why so seriouS
 Аватар для Why so seriouS
44 / 44 / 1
Регистрация: 12.03.2013
Сообщений: 167
24.03.2013, 19:14  [ТС]     освобождение памяти #5
Цитата Сообщение от go Посмотреть сообщение
дайте больше информации.
Эту программу я переводил с Си в С++. В Си она работает а на с + + не хочет. Больше информации нет.
Си
Кликните здесь для просмотра всего текста
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
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <locale.h>
 
void InputDimenstion (void);
double **CreateArray (void);
void PrintMatrix (char* info, double *matr[], int print_sum);
void SortRows (double **matr);
void WriteMatrix (double *pmatrix []);
void WriteSum (double *pmatrix[]);
void DeleteArray (double** matr, int rdel);
double EnergyAlphaParticle (double Z);
double ParticleCharge (void);
 
// Константи, що описують параметри фізичного процесу
const double H = 1;
const double Q = 1e4;
const double Epsilon = 1e-4;
const double Alpha = 1e-9;
const double PI = 3.1415926;
const double Z = 1;
const double R1 = 0.1;
const double Beta = 1e-3;
 
const int RAND_INIT = 10;
 
// файл для збереження матриці значень енергій
const char fn_matrix [] = "matrix.dat";
const char fn_sum[] = "sum.dat";
 
// розмірність матриці енергії
int nrows, ncolms;
 
int main (int argc, char* argv[])
{
 setlocale(LC_ALL,"Ukrainian");
 double **parray;
 InputDimenstion ();
 parray = CreateArray();
 
 if (parray == NULL)
  return 1;
 
 PrintMatrix ("Матриця енергiй:", parray, false);
 WriteMatrix (parray);
 
 SortRows (parray);
 PrintMatrix ("Вiдсортована матриця:", parray, true);
 WriteSum (parray);
 
 DeleteArray (parray, nrows);
 return 0;
}
/**
* Ввід розмірності матриці
* Глобальним змінним nrows та ncolms присвоюється відповідні значення
* кількості рядків і стовбців матриці
*/
 
void InputDimenstion(void)
{
    printf("Matrix dimension[MxN] - ");
        scanf("%dx%d",&nrows,&ncolms);
}
 
/**
* Заповнення матриці значеннями
* енергій альфа-частинок
*/
 
double **CreateArray(void)
{
        double **pmatrix; // вказівник на матрицю
        int k,j;
        double delta;
 
        // виділення пам'яті для масиву вказівників на початки рядків матриці
 
        pmatrix = (double**) calloc(nrows,sizeof (double* ));
        if(!pmatrix)
        {
                perror("Error ! - can`t allocate memory");
                return NULL;
        }
 
        // запуск генератора випадкових чисел
 
        srand(RAND_INIT);
 
        for(k = 0; k < nrows;k++)
        {
                // виділення памяті для рядка матриці
                pmatrix[k] = (double*) calloc(ncolms + 1, sizeof (double));
 
                if(*(pmatrix + k) == NULL)
                {
                        DeleteArray(pmatrix,k);
                        return NULL;
                }
 
                // заповнення нового рядка значеннями енергій
                for(j = 0; j < ncolms; j++)
                {
                        delta = (double)(j + 1)/ncolms;
                        pmatrix[k][j] = EnergyAlphaParticle(delta);
                }
        }
        return pmatrix;
}
 
/**
* Вивід матриці енергій на дисплей
* info - назва матриці
* prow - вказівник на матрицю
* print_sum - чи виводити значення суми енергій для рядка
*/
 
void PrintMatrix(char* info,double *pmatrix[],int print_sum)
{
        double **prow,*pnode;
        int k,j;
 
        puts(info);
 
        for(k = 0, prow = pmatrix; k < nrows; k++ , prow++)
        {
                for(j = 0, pnode = *prow; j < ncolms; j++,pnode++)
                {
                        printf("%9.5f", *pnode);
                }
                if(print_sum)
                        printf("%14.31f",*(*prow + ncolms));
                printf("\n");
        }
}
 
// Запис матрм=иці енергій у файл
// prow - вказівник на матрицю
 
void WriteMatrix (double *pmatrix[])
{
 double **prow, *pnode;
 int k, j;
 
 FILE *fl;
 fl = fopen (fn_matrix, "w");
 
 if (!fl)
  {
   printf ("Can`t open file!!!\n");
   return;
  }
  
 for (k = 0; prow = pmatrix,k < nrows; k++,prow++)
  {
   for (j = 0, pnode = *prow; j < ncolms; j++, pnode++)
    {
     fprintf (fl, "9.5lf", *pnode);
    }
   fprintf (fl, "\n");
  }
 fclose (fl);
}
 
// Запис сум рядків матриці у файл
// prow - вказівник на матрицю
 
void WriteSum (double *pmatrix[])
{
 double **prow, *pnode;
 int k, j;
 
 FILE *fl;
 fl = fopen (fn_sum, "w");
 if (!fl) 
 {
  printf ("Cant open file!!!\n");
  return;
 }
 
 for (k = 0, prow = pmatrix; k < nrows; k++, prow++)
  {
   fprintf (fl, "%14.31f\n", *(*prow + ncolms));
  }
 fclose(fl);
}
 
// Сортування рядків матриці за значенням енергій
// в рядку
 
void SortRows(double **pmatrix)
{
        double **prow, **prow2;
        double *pcell, *psum;
        double *tmp;
 
        for(prow = pmatrix; prow < pmatrix + nrows; prow++)
                for(pcell = *prow, psum = *prow + ncolms; pcell < psum; pcell++)
                        *psum += *pcell;
 
        for(prow = pmatrix; prow < pmatrix + nrows - 1; prow++)
                for(prow2 = prow + 1; prow2 < pmatrix + nrows; prow2++)
                        if((*prow)[ncolms] > (*prow2)[ncolms])
                        {
                                tmp = *prow;
                                *prow = *prow2;
                                *prow2 = tmp;
                        }
}
 
/**
* Звільнення зайнятої памяті
*/
 
void DeleteArray(double **pmatrix, int rows)    
{
        double **prow;
 
        for(prow = pmatrix; prow < pmatrix + rows; prow++)
                free(*prow);
        free(pmatrix);
}
 
/**
* Енергія альфа-частинки
*/
 
double EnergyAlphaParticle(double Z)
{
        double W;
        double charge = ParticleCharge();
        W = charge*Q/(2 * PI *Epsilon*H)*log(Z/R1);
        return W;
}
 
/**
* Величина заряду альфа-частинки
*/
 
double ParticleCharge(void)
{
        double charge;
        double factor = rand();
        charge = (Beta * factor)*Alpha;
        return charge;
}

С++
Кликните здесь для просмотра всего текста
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
#include <iostream>
#include <math.h>
#include <time.h>
#include <stdio.h>
#include <fstream>
#include <cstdlib>
 
using namespace std;
 
void InputDimenstion();
double** CreateArray();
void PrintMatrix(char* info,double *matr[],int print_sum);
void SortRows(double**matr);
void WriteMatrix(double *pmatrix[]);
void WriteSum(double *pmatrix[]);
void DeleteArray(double**matr,int rdel);
double EnergyAlphaParticle(double);
double ParticleCharge();
 
const double H = 1;
const double Q = 1e4;
const double Epsilon = 1e-4;
const double Alpha = 1e-9;
const double PI = 3.1415926;
const double Z = 1;
const double R1 = 0.1;
const double Beta = 1e-3;
 
const int RAND_INT = 10;
 
const char fn_matrix[] =  "matrix.txt";
const char fn_sum[] =  "sum.txt";
 
int nrows, ncolms;
 
int main()
{
    double **parray;
    InputDimenstion();
    parray = CreateArray();
    if(parray == NULL)
        return 1;
 
    PrintMatrix("Matrix energy:",parray,false);
    WriteMatrix(parray);
 
    SortRows(parray);
    PrintMatrix("Sort matrix:",parray,true);
    WriteSum(parray);
 
    //DeleteArray(parray,nrows);
    
    system("pause>0");
    return 0;
}
 
void InputDimenstion()
{
    cout<<"Matrix dimension[MxN] - ";
    cin>>nrows>>ncolms;
}
 
double **CreateArray()
{
    double **pmatrix;
    int k,j;
    double delta;
 
    pmatrix = new double*[nrows];
    if(!pmatrix){
        cerr<<"Error!";
        return NULL;
    }
    
    for(k=0;k<nrows;++k){
        pmatrix[k] = new double[ncolms];
 
        if(pmatrix[k] == NULL){
            DeleteArray(pmatrix,k);
            return NULL;
        }
 
        for(j = 0;j < ncolms; ++j){
            delta = static_cast<double>(j+1) / ncolms;
            pmatrix[k][j] = EnergyAlphaParticle(delta);
        }
    }
    return pmatrix;
}
 
void PrintMatrix(char* info,double *pmatrix[],int print_sum)
{
    double **prow, *pnode;
    int k,j;
 
    cout<<info<<endl;
 
    for(k = 0, prow = pmatrix; k < nrows; ++k, ++prow,cout<<endl){
        for(j = 0, pnode = *prow; j < ncolms; ++j, ++pnode){
            cout<<(*pnode)<<" ";
        }
        if(print_sum)
            cout<<(*(*prow + ncolms))<<" ";
    }
}
 
void WriteMatrix(double *pmatrix[])
{
    double **prow, *pnode;
    int k,j;
 
    ofstream f1("matrix.txt",ios::in);
    
    if(!f1){
        cerr<<"Cant open file!!!"<<endl;
        return;
    }
    for(k = 0, prow = pmatrix;k < nrows; ++k, ++prow){
        for(j = 0,  pnode = *prow; j < ncolms ; ++j, ++pnode){
            f1 << (*pnode);
        }
        f1 << endl;
    }
    f1.close();
}
 
void WriteSum(double *pmatrix[])
{
    double **prow;
    int k;
 
    ofstream f1(fn_sum,ios::in);
    if(!f1){
        cerr<<"Cant open file!!!"<<endl;
        return;
    }
    for(k = 0, prow = pmatrix; k < nrows; ++k, ++prow){
        f1 << (*(*prow + ncolms)) << " ";
    }
    f1.close();
}
 
void SortRows(double **pmatrix)
{
    double **prow, **prow2;
    double *pcell, *psum;
    double *tmp;
 
    for(prow = pmatrix; prow < pmatrix + nrows; ++prow)
        for(pcell = *prow, psum = *prow + ncolms; pcell < psum; ++pcell)
            *psum += *pcell;
 
    for(prow = pmatrix; prow < pmatrix + nrows - 1; ++prow)
        for(prow2 = prow + 1; prow2 < pmatrix + nrows; ++prow2){
            if((*prow)[ncolms] > (*prow2)[ncolms]){
                tmp = *prow;
                *prow = *prow2;
                *prow2 = tmp;
            }
        }
}
 
void DeleteArray(double **pmatrix, int rows)
{
    double **prow;
    
    for(prow = pmatrix; prow < pmatrix + rows; ++prow)
        delete [] (*prow);
    
    delete [] pmatrix;
}
 
double EnergyAlphaParticle(double Z)
{
    double W;
    double charge = ParticleCharge();
 
    W = charge * Q / (2 * PI * Epsilon * H) * log(Z / R1);
 
    return W;
}
 
double ParticleCharge()
{
    double charge;
    double factor = rand();
 
    charge = (Beta * factor) * Alpha;
 
    return charge;
}
Yandex
Объявления
24.03.2013, 19:14     освобождение памяти
Ответ Создать тему
Опции темы

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