Форум программистов, компьютерный форум, киберфорум
Наши страницы
C для начинающих
Войти
Регистрация
Восстановить пароль
 
Ваю
20 / 20 / 9
Регистрация: 21.04.2015
Сообщений: 567
1

Malloc ошибка освобождения памяти

25.12.2016, 23:36. Просмотров 317. Ответов 10
Метки нет (Все метки)

ЧЯДНТ? Косяк такой:

heap corruption detected before normal block (№0) at 0x...
CRT detected that the application wrote to memory before start of heap buffer.

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
double SizeArr = 5, wData = 8, **Arr0, *Arr1, *Arr2;
 
Len = SizeArr * sizeof(double);
Arr0 = (double**)malloc(SizeArr * sizeof(*Arr0));
    for (i = 0; i < SizeArr; ++i) Arr[i] = (double*)malloc(Len);
 
Arr1 = (double*)malloc(Len);
Arr2 = (double*)malloc(Len);
 
for (i = 0; i < SizeArr; ++i) 
    Arr[i] = (double*)realloc(Arr[i], wData * sizeof(*Arr));
 
free(Arr1); Arr1 = NULL; // нет ошбки
free(Arr2); Arr2 = NULL; // ошибка
for (i = 0; i < SizeArr; ++i) 
    free(Arr0[i]); // ошибка - срабатывание точки останова
free(Arr0); Arr0 = NULL;
Добавлено через 32 минуты
Код целиком
Кликните здесь для просмотра всего текста

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
#include <math.h>
#include <stdio.h>
#include <iostream>
#include <ctime>
 
void mxmt(double **Data, double **Arr, size_t wData, size_t SizeArr);
void tred2(double **Arr, size_t SizeArr, double *D0, double *D1);
void tqli1(double **Arr, size_t SizeArr, double *D0, double *D1, size_t *MaxIter);
void bevm(double **Arr, size_t SizeArr, double *D0, double *D1, double **DT);
void ivm(double **DT, double *D0, size_t SizeArr);
void vxb(double *A, double **B, double **C, size_t whM, size_t wB);
void smdd(double **C, double *D0, size_t SizeArr);
void axb(double **A, double **B, double **C, size_t hA, size_t whM, size_t wB);
void output1(double *D, size_t SizeArr);
void output2i(double **Arr, size_t SizeArr);
void output2t(double **Arr, size_t SizeArr);
void output2r(double **Arr, size_t SizeArr, size_t wData);
void output2rt(double **Arr, size_t SizeArr, size_t wData);
 
int main() {
    setlocale(0, "ru-ru"); srand((size_t)time(0));
    double **Data, **Arr, **DT, *D0, *D1, **SU;
    size_t i, SizeArr = 5, wData = 8, Len, *MaxIter = &i;
  
    Len = wData * sizeof(**Data);
    Data = (double**)malloc(SizeArr * sizeof(*Data));
        for (i = 0; i < SizeArr; ++i) Data[i] = (double*)malloc(Len);
    
    for (i = 0; i < SizeArr; ++i) 
        for (size_t j = 0; j < wData; ++j) Data[i][j] = 5 - rand() % 11;
 
    Len = SizeArr * sizeof(double);
    Arr = (double**)malloc(SizeArr * sizeof(*Arr));
        for (i = 0; i < SizeArr; ++i) Arr[i] = (double*)malloc(Len);
 
    mxmt(Data, Arr, wData, SizeArr); 
    puts("Исходные данные (Data): "); output2r(Data, SizeArr, wData);
    puts("Исходная левая симметричная матрица (Data x Data^T): "); output2i(Arr, SizeArr);
 
    D0 = (double*)malloc(Len); //memset(&D0[0], 0, Len);
  D1 = (double*)malloc(Len); //memset(&D1[0], 0, Len);
    DT = (double**)malloc(3 * sizeof(**DT));
        for (i = 0; i < 3; i++) DT[i] = (double*)malloc(Len);
 
    tred2(Arr, SizeArr, D0, D1);
    for (i = 0; i < SizeArr; ++i) { DT[0][i] = D0[i]; DT[1][i] = D1[i]; }
    i = 30; tqli1(Arr, SizeArr, D0, D1, MaxIter);
    for (i = 0; i < SizeArr; ++i) DT[2][i] = D0[i];
    puts("Собственные значения (L): "); output1(D0, SizeArr);
    bevm(Arr, SizeArr, D0, D1, DT);
    puts("Собственные векторы (V): "); output2t(Arr, SizeArr);
    ivm(DT, D0, SizeArr);
    puts("Обратный вектор сингулярных значений (S'): "); output1(D0, SizeArr);
 
    // Arr = D0 x Arr x Data [ V^(T) = (S^(T))^(-1) x U^(T) x A ]
    SU = (double**)malloc(SizeArr * sizeof(**SU));
        for (i = 0; i < SizeArr; i++) SU[i] = (double*)malloc(Len);
    
    // используем формулу умножения вектора на не транспонированную матрицу, 
    // поскольку её содежимое уже транспонировано
    vxb(D0, Arr, SU, SizeArr, SizeArr); //output2t(SU, SizeArr);
    smdd(SU, D0, SizeArr); //output2t(SU, SizeArr);
 
    for (i = 0; i < SizeArr; ++i) 
        Arr[i] = (double*)realloc(Arr[i], wData * sizeof(*Arr));
 
    axb(SU, Data, Arr, SizeArr, SizeArr, wData);
    puts("Матрица векторов (V), нулевые вектора опущены: "); output2rt(Arr, wData, SizeArr);
 
    system("pause");
 
    for (i = 0; i < SizeArr; ++i) free(Data[i]); free(Data); Data = NULL;
    for (i = 0; i < SizeArr; ++i)   free(SU[i]); free(SU); SU = NULL;
    for (i = 0; i < 3; ++i) free(DT[i]); free(DT); DT = NULL;
    free(D0); D0 = NULL;
    //free(D1); //D1 = NULL;
    for (i = 0; i < SizeArr; ++i) 
        free(Arr[i]); 
    //free(Arr); Arr = NULL;
    
    return 0;
}
 
void mxmt(double **Data, double **Arr, size_t wData, size_t SizeArr) {
    for (size_t i = 0; i < SizeArr; ++i)
        for (size_t j = i; j < SizeArr; ++j) {
            Arr[j][i] = 0.;
            for (size_t k = 0; k < wData; ++k)
                Arr[j][i] += Data[i][k] * Data[j][k];
            Arr[i][j] = Arr[j][i];
        }
}
 
void tred2(double **Arr, size_t SizeArr, double *D0, double *D1) {
    size_t i, j, k, l; double Scale, Sum, Pre, HH;
    
    /* получение ортогональной матрицы трансформации */
    /* проход по стадиям/итерациям процесса редукции */
    for (i = SizeArr - 1; i > 0; --i) {
      l = i - 1; D0[i] = Scale = 0.;
    
      /* вычислить сумму модулей строки под главной диагональю */
      for (j = 0; j < i; ++j) Scale += fabs(Arr[i][j]);
    
      /* сложный процесс везде, кроме последней стадии/итерациям, весь 
      обрабатываемый диапазон находится под главной диагональю матрицы */
      if (i < 2 || !Scale) D1[i] = Arr[i][l];
      else { /* преобразование матрицы */
        /* масштабируем строку */
        for (j = 0; j < i; ++j) Arr[i][j] /= Scale;
    
        /* вычислить сумму квадратов строки */
        for (j = 0; j < i; ++j) D0[i] += Arr[i][j] * Arr[i][j];
    
        /* работаем с вектором U */
        D1[i] = (Arr[i][l] < 0. ? sqrt(D0[i]) : -sqrt(D0[i]));
        D0[i] -= Arr[i][l] * D1[i]; Arr[i][l] -= D1[i];
        D1[i] *= Scale;
    
        /* вычисляем предварительный коэффициент Pre */
        for (Pre = 0., j = 0; j < i; ++j) {
          Arr[j][i] = Arr[i][j] / D0[i];
          for (Sum = 0., k = 0; k <= j; ++k) Sum += Arr[j][k] * Arr[i][k];
          for (k = j + 1; k < i; ++k) Sum += Arr[k][j] * Arr[i][k];
          D1[j] = Sum / D0[i]; Pre += Arr[i][j] * D1[j];
        }
        /* трансформируем матрицу */
        HH = Pre / (D0[i] + D0[i]);
        for (j = 0; j < i; ++j) {
          D1[j] -= HH * Arr[i][j];
          for (k = 0; k <= j; ++k)
            Arr[j][k] -= (D1[k] * Arr[i][j] + D1[j] * Arr[i][k]);
        }
      }
    }
    /* сохраняем главную диагональ */
    for (D1[0] = 0., i = 0; i < SizeArr; ++i) D0[i] = Arr[i][i]; /**/
}
 
void tqli1(double **Arr, size_t SizeArr, double *D0, double *D1, size_t *MaxIter) {
  size_t i, j, k, Iter; double b, c, DD, f, g, p, r, s;
 
  /* сдвигаем массив влево для удобства */
  for (i = 1; i < SizeArr; ++i) D1[i - 1] = D1[i]; D1[i - 1] = 0.;
      
  for (i = 0; i < SizeArr; ++i) {
    Iter = *MaxIter;
    do { /* диагонализируем миноры с текущей строки */
      /* находим малый поддиагональный элемент для расщепления */
      for (j = i; j < SizeArr - 1; ++j) {
        DD = fabs(D0[j]) + fabs(D0[j + 1]);
        if ((double)(fabs(D1[j] + DD)) == DD) break;
      }
      /* если верхний левый угол минора еще не диагональный */
      if (j != i) {
        /* формирование сдвига */
        g = (D0[i + 1] - D0[i]) / (2. * D1[i]); r = hypot(1., g);
        /* находим сумму модулей d_m и k_s с сохранением исходного знака */
        g += (g >= 0. ? fabs(r) : -fabs(r)); g = D0[j] - D0[i] + D1[i] / g;
        /* плоская ротация оригинального QL алгоритма, сопровождаемая
        ротациями Гивенса для восстановления трехдиагональной формы */
                for (s = c = 1., p = 0., k = j - 1; k < j && k >= i; --k) {
          f = s * D1[k]; b = c * D1[k]; D1[k + 1] = r = hypot(f, g);
          if (r == 0.) { D0[k + 1] -= p; D1[j] = 0.; break; }
          /* основные действия на ротации */
          s = f / r; c = g / r; g = D0[k + 1] - p;
          r = (D0[k] - g) * s + 2. * c * b;
          p = s * r; D0[k + 1] = g + p; g = c * r - b;
        }
        /* безусловный переход к новой итерации при нулевом знаменателе
        и недоведенной до конца последовательности ротаций */
        if (r == 0. && k < j && k >= i) continue;
        /* сохраняем новые значения диагоналей */
        D0[i] -= p; D1[i] = g; D1[j] = 0.;
      }
    } while (j != i && --Iter);
    if (!Iter) { printf("Привышен заданный порог итераций на цикле %d \n", i); break; }
  }
}
 
void bevm(double **Arr, size_t SizeArr, double *D0, double *D1, double **DT) {
    double Div, Delta; size_t i, j, k, l, Rang;
    // цикл поиска сбственных векторов для каждого собственого значения
    for (i = 0; i < SizeArr; ++i) {
        // получаем главную и прилигающие к ней диагонали
        for (j = 0; j < SizeArr; ++j) { D0[j] = DT[0][j] - DT[2][i]; D1[j - 1] = DT[1][j]; }
        // получаем триугольную/трапциидальную матрицу из трёхдиагональной
        Div = 1.; Rang = l = SizeArr - 1; D1[l] = D1[0];
        for (j = 0, k = 1; k < l; ++j, ++k) {
            D0[k] = (D0[j] * D0[k] - D1[l] * D1[j]) / Div;
            D1[l] = D1[k]; D1[k] = D0[j] / Div * D1[k]; Div = D0[j];
        }
        // подсчитываем среднюю линейную погрешность с некоторым запасом
        // кого это не устраивает - считает погрешность как положено
        D0[k] = (D0[j] * D0[k] - D1[l] * D1[j]) / Div;
        Delta = 1.00059 * D0[k]; Div = D0[k] / k; D0[k] = 1.;
        // поиск свободных значений / подсчёт ранга матрицы
        for (j = SizeArr - 2; j; --j, Delta -= Div)
            if (fabs(D0[j]) < Delta && fabs(D1[j]) < Delta) { D0[j] = 1.; --Rang; }
            else break;
        // получаем собственный вектор для текущего собственного значения
        for (j = Rang - 1, k = Rang; j < Rang; --j, --k) D0[j] = -D0[k] / D0[j] * D1[j];
        // нормализуем вектор
        Div = 0.; for (j = 0; j < SizeArr; ++j) Div += D0[j] * D0[j];
        Div = sqrt(Div); for (j = 0; j < SizeArr; ++j) D0[j] /= Div;
        // сохраняем результат в массив векторов в транспонированном виде (по строкам)
        for (j = 0; j < SizeArr; ++j) Arr[i][j] = D0[j];
    }
}
 
void ivm(double **DT, double *D0, size_t SizeArr) {
    size_t i; // подсчитываем сингулярные значения
    for (i = 0; i < SizeArr; ++i) D0[i] = (DT[2][i] > 0 ? sqrt(DT[2][i]) : 0);
    // находим обратную вектор матрицу
    for (i = 0; i < SizeArr; ++i) D0[i] = 1. / D0[i];
}
 
void vxb(double *V, double **B, double **C, size_t whM, size_t wB) {
    size_t i, j;
    for (i = 0; i < whM; ++i) for (j = 0; j < wB; ++j) C[i][j] = V[i] * B[i][j];
}
 
void smdd(double **C, double *D0, size_t SizeArr) {
    // сортировка строк матрицы по убыванию значений вектор матрицы
    size_t Pos = 0, i, j; double Max, Swp, *pSwp;
    for (i = 0; i < SizeArr - 1; ++i) {
        for (j = i + 1, Max = D0[i]; j < SizeArr; ++j)
            if (Max < D0[j]) Max = D0[j], Pos = j;
        if (i != Pos) {
            Swp = D0[i]; D0[i] = D0[Pos]; D0[Pos] = Swp;
            pSwp = C[i]; C[i] = C[Pos]; C[Pos] = pSwp;
        }
    }
}
 
void axb(double **A, double **B, double **C, size_t hA, size_t whM, size_t wB) {
    for (size_t i = 0; i < hA; ++i)
        for (size_t j = 0; j < wB; ++j) {
            C[i][j] = 0.; 
            for (size_t k = 0; k < whM; ++k) C[i][j] += A[i][k] * B[k][j];
        }
}
 
void output1(double *a, size_t n) {
  for (size_t x = 0; x < n; ++x) printf("%14.10lf ", a[x]); puts("\n");
}
 
void output2i(double **a, size_t n) {
    for (size_t y = 0; y < n; ++y) {
        for (size_t x = 0; x < n; ++x) printf("%5.0lf ", a[y][x]); puts("");
    } puts("");
}
 
void output2t(double **a, size_t n) {
  for (size_t y = 0; y < n; ++y) {
    for (size_t x = 0; x < n; ++x) printf("%14.10lf ", a[x][y]); puts("");
  } puts("");
}
 
void output2r(double **a, size_t n, size_t m) {
    for (size_t y = 0; y < n; ++y) {
        for (size_t x = 0; x < m; ++x) printf("%5.0lf ", a[y][x]); puts("");
    } puts("");
}
 
void output2rt(double **a, size_t n, size_t m) {
    for (size_t y = 0; y < n; ++y) {
        for (size_t x = 0; x < m; ++x) printf("%14.10lf ", a[x][y]); puts("");
    } puts("");
}
0
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
25.12.2016, 23:36
Ответы с готовыми решениями:

Ошибка освобождения динамической памяти
Столкнулся с проблемой ошибка при очистке динамической памяти помогите разобраться что я сделал не...

Ошибка при переходе в функцию освобождения памяти из под списка
При переходе в функцию Clear вылетает с сообщением что куча была повреждена. Какая строка ее...

Распределение памяти для выделения и освобождения блоков памяти внутри запрошенного пула
В программе малые&quot;дыры&quot; избегают,что нужно сделать что бы малые &quot;дыры&quot; не избегались.... #...

Почему после освобождения памяти получается записать туда значение
Здравствуйте! Вот код: #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; int main() { int * p...

Выделение памяти под структуры (malloc)
Доброго времени суток! Нужна помощь в выделении памяти для структуры с указателями. Можете...

10
shvyrevvg
737 / 549 / 275
Регистрация: 12.05.2016
Сообщений: 1,599
26.12.2016, 04:45 2
Ваю, 33 и 56 строки сравните, ничего не смущает?
1
Ваю
20 / 20 / 9
Регистрация: 21.04.2015
Сообщений: 567
26.12.2016, 12:26  [ТС] 3
Было:
C++
1
2
3
4
5
Arr = (double**)malloc(SizeArr * sizeof(*Arr));
    for (i = 0; i < SizeArr; ++i) Arr[i] = (double*)malloc(Len);
 
SU = (double**)malloc(SizeArr * sizeof(**SU));
    for (i = 0; i < SizeArr; ++i) SU[i] = (double*)malloc(Len);
Стало:
C++
1
2
3
Arr = (double**)malloc(SizeArr * sizeof(**Arr));
for (i = 0; i < SizeArr; ++i) Arr[i] = (double*)realloc(Arr[i], wData * sizeof(**Arr));
D1 = (double*)malloc(Len);
Лыжи не едут с D1... косяк в заголовке шапки
0
shvyrevvg
737 / 549 / 275
Регистрация: 12.05.2016
Сообщений: 1,599
26.12.2016, 12:35 4
Ваю, чем **Arr отличается от *Arr, под что Вы память выделяете и сколько ее нужно? Запишите sizeof() без Arr, через double.
0
Ваю
20 / 20 / 9
Регистрация: 21.04.2015
Сообщений: 567
26.12.2016, 12:47  [ТС] 5
shvyrevvg, не в нём ошибка, это я исправил, ошибка с

heap corruption detected before normal block (№0) at 0x...
CRT detected that the application wrote to memory before start of heap buffer.

C++
1
2
3
4
5
Len = SizeArr * sizeof(double);
D0 = (double*)malloc(Len);
D1 = (double*)malloc(Len);
free(D0); // тут всё хорошо
free(D1); // тут косяк
0
shvyrevvg
737 / 549 / 275
Регистрация: 12.05.2016
Сообщений: 1,599
26.12.2016, 12:54 6
Ваю, так ошибку получаете? Нет.
C
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
#include <stdlib.h>
 
int main(void)
{
    size_t SizeArr = 10;
    size_t Len = SizeArr * sizeof(double);
    double *D0 = (double*)malloc(Len);
    double *D1 = (double*)malloc(Len);
    free(D0); // тут всё хорошо
    free(D1); // тут косяк
    return 0;
}
0
Ваю
20 / 20 / 9
Регистрация: 21.04.2015
Сообщений: 567
26.12.2016, 13:03  [ТС] 7
shvyrevvg, да, ошибка есть, я забыл дописать строчку с инициаизацией в посте с описанием ошибки, но всё это есть под катом с полным текстом кода пограммы

C++
1
size_t SizeArr = 5, Len;
0
TheCalligrapher
С чаем беда...
Эксперт CЭксперт С++
4848 / 2492 / 696
Регистрация: 18.10.2014
Сообщений: 4,326
26.12.2016, 13:12 8
Цитата Сообщение от Ваю Посмотреть сообщение
ЧЯДНТ?
1. Наличествуют явные приведения типа результата malloc.

2. Наличествует какое-то кроилово в sizeof под malloc

Что вот это такое

C
1
DT = (double**)malloc(3 * sizeof(**DT));
?

Классической идиомой выделения памяти через malloc является

C
1
p = malloc(n * sizeof *p);
Откуда у вас под sizeof вдруг возникло две звезды вместо одной?


3. Цикл в bevm

C
1
for (j = 0; j < SizeArr; ++j) { D0[j] = DT[0][j] - DT[2][i]; D1[j - 1] = DT[1][j]; }
Делается запись по индексу -1 в D1. В чем идея?

4. Печать переменной типа size_t через %d ?

C
1
printf("Привышен заданный порог итераций на цикле %d \n", i)
1
Ваю
20 / 20 / 9
Регистрация: 21.04.2015
Сообщений: 567
26.12.2016, 13:18  [ТС] 9
DT = двумерный double массив, точнее массив массивов, размером [3][Len]. sizeof(**DT) = 8 байт, как и положено для double
0
TheCalligrapher
С чаем беда...
Эксперт CЭксперт С++
4848 / 2492 / 696
Регистрация: 18.10.2014
Сообщений: 4,326
26.12.2016, 13:24 10
Цитата Сообщение от Ваю Посмотреть сообщение
DT = двумерный double массив, точнее массив массивов, размером [3][Len]. sizeof(**DT) = 8 байт, как и положено для double
DT у вас - массив указателей типа double *, которые указывают на "подмассивы" более низкого уровня. Именно так и получается ваш двумерный массив. Поэтому выделять вам надо именно 3 * sizeof *DT байт. А sizeof double вам понадобится только при выделении подмассивов, что вы и делаете потом в цикле.

Что характерно, при выделении двумерных массивов Data и Arr у вас этого косяка нет. А с DT - вдруг есть. Разные люди писали?
1
Ваю
20 / 20 / 9
Регистрация: 21.04.2015
Сообщений: 567
26.12.2016, 13:54  [ТС] 11
исправил на:
C++
1
2
D0[0] = DT[0][0] - DT[2][i];
for (j = 1; j < SizeArr; ++j) { D0[j] = DT[0][j] - DT[2][i]; D1[j - 1] = DT[1][j]; }
Добавлено через 15 минут
спасибо, переписал указатели
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
Len = wData * sizeof(**Data);
Data = (double**)malloc(SizeArr * sizeof(*Data));
    for (i = 0; i < SizeArr; ++i) Data[i] = (double*)malloc(Len);
 
Len = SizeArr * sizeof(double);
Arr = (double**)malloc(SizeArr * sizeof(*Arr));
    for (i = 0; i < SizeArr; ++i) Arr[i] = (double*)malloc(Len);
 
DT = (double**)malloc(3 * sizeof(*DT));
    for (i = 0; i < 3; ++i) DT[i] = (double*)malloc(Len);
 
SU = (double**)malloc(SizeArr * sizeof(*SU));
    for (i = 0; i < SizeArr; ++i) SU[i] = (double*)malloc(Len);
 
for (i = 0; i < SizeArr; ++i) free(Data[i]); free(Data); Data = NULL;
for (i = 0; i < SizeArr; ++i) free(Arr[i]); free(Arr); Arr = NULL;
for (i = 0; i < SizeArr; ++i) free(SU[i]); free(SU); SU = NULL;
for (i = 0; i < 3; ++i) free(DT[i]); free(DT); DT = NULL;
free(D0); D0 = NULL;
free(D1); D1 = NULL;
Добавлено через 13 минут
Цитата Сообщение от TheCalligrapher Посмотреть сообщение
Что характерно, при выделении двумерных массивов Data и Arr у вас этого косяка нет. А с DT - вдруг есть. Разные люди писали?
Всё моё, это просто рандом, корявое выделение памяти перекрывается только в одном месте, тем самым разрушая данные массива D1, вследствии чего оно и падало. С DT вдруг eсть поскольку куски кода написаны с разницей почти 2 года, а с маллоком я не работал никогда, накосячил, просто забыл как пользоваться, изначально там был реаллок, я поудалял всё и оставил маллок
0
26.12.2016, 13:54
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
26.12.2016, 13:54

Динамическое выделение памяти, нужен ли <malloc.h>?
если используешь функцию malloc, обязательно перед этим подключать соответствующую библиотеку...

Компилятор ругается на выделение памяти malloc
#include &lt;stdio.h&gt; #include &lt;conio.h&gt; #include &lt;string.h&gt; #include &lt;locale.h&gt; /* СТУДЕНТ: ...

Понять динамическое распределение памяти (malloc)
Пытаюсь понять динамическое распределение памяти, но пока безрезультатно. Написал код: ...


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

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

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