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

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

Войти
Регистрация
Восстановить пароль
 
 
Рейтинг: Рейтинг темы: голосов - 11, средняя оценка - 4.64
CheburatorUA
0 / 0 / 0
Регистрация: 27.03.2014
Сообщений: 24
#1

Переопределение размера массива указателей - C++

11.08.2014, 15:05. Просмотров 1498. Ответов 34
Метки нет (Все метки)

Доброе время суток. Столкнулся с неожиданно проблемой, не могу решить. Поиск по форуму ничего не дал.
Есть элементарный код:
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <iostream>
using namespace std;
 
void main()
{
    int i=0;
    const int n = 3;
    int *b[n];
    while(i<n)
    {
        b[i] = new int;
        i++;
    }
    i=0;
    *b[0] = 1;
    *b[1] = 2;
    *b[2] = 3;
    while (i<n)
        {
            cout<<*b[i]<<endl;
            i++;
        }
}
Т.е ничего сложного - выделяем массив указателей затем по ним выделяем память, записываем в неё значение и выводим его на экран. Так вот вопрос: возможно ли размер этого массива определять вручную с консоли или как-то его задать на основе предварительных расчетов? Не константное значение компилятор не принимает. Такой вот код int a = 2+1; const int n = a; int *b[n]; не принимает говорит, что n не константа. Такой тоже int a = 2+1; int *b[a] не компилирует; Как я не кручу не получается т.е. или надо писать *b[3] или const int n = 3; int *b[n]; А мне нужно в процессе выполнения программы задать размер на основе предшествующего расчета.
Лучшие ответы (1)
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
11.08.2014, 15:05     Переопределение размера массива указателей
Посмотрите здесь:

Задание размера и инициализация массива указателей в конструкторе - C++
1) h: SDL_Texture *textures; Как задать размер и инициализировать в конструкторе? Если пишу так: SDL_Texture *textures; ...

Переопределение массива - C++
Здравствуйте уважаемые участники!) Задался на С++ вопросом переопределение массива. В Visual Basic я делал так Dim a() as integer N...

Переопределение массива - C++
Как переопределить массив в С++ с сохранением старых значений? Код навроде такого int Size = 1; int i = 0; int Array* = new...

Удаление массива указателей - C++
есть класс: class test { private: static test **list; static int count_object; public: void mesto::Add() {

Сортировка массива указателей - C++
Всем доброго вечера Столкнулся я с проблемой примерно вот такого: типа у меня есть класс class tourism { friend tourism...

Связь массива и указателей - C++
Доброго времени суток, начал учить указатели и тут такая задача: Дан массив целых чисел. Воспользовавшись указателями, поменяйте местами...

Программирование массива указателей - C++
Подскажите, в чем различие выделения памяти для массива указателей char **term;: term = (char **)malloc(10); и *term = (char...

После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
WinRar007
1 / 1 / 0
Регистрация: 08.04.2014
Сообщений: 80
21.08.2014, 19:48     Переопределение размера массива указателей #21
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
void render(float loops, bool joints, bool movement, bool collision)    // Один шаг симуляции
    {
        if (loops == 0)
        {
            loops = 1;
        }
        for (int L = 0; L < loops; L++)        // Под-шаги симуляции (Чем быстрее симуляция,
        {                                      //             тем больше под-шагов (Для большей точности))
            if (joints)   // Сила тяжести (И прочие силы, если захочешь свои добавить)
            {
                for (i = 0; i < Bodies.N; i++)
                {
                    for (i2 = 0; i2 < Bodies.N; i2++)
                    {
                        if (i != i2)
                        {
                            Joints(Settings.Time / loops, Bodies.Massive[i], Bodies.Massive[i2]);
                        }
                    }
                }
            }
            if (collision)   // Проверка столкновений...
            {
                for (i = 0; i < Bodies.N; i++)
                {
                    for (i2 = 0; i2 < Bodies.N; i2++)
                    {
                        if (i != i2)
                        {
                            CheckCollision(Settings.Time / loops, Bodies.Massive[i], Bodies.Massive[i2]);
                        }
                    }
                }
            }
            if (movement)   //Передвигаем объекты...
            {
                for (i = 0; i < Bodies.N; i++)
                {
                    Movement(Settings.Time / loops, Bodies.Massive[i]);
                }
            }
        }
    }
И что находится в этих элементах массива?
Должен находится указатель, записанный этой функцией:
C++
1
2
3
4
5
6
7
8
9
10
11
12
void AddToRander(Body *Obj)
    {
        if (Bodies.Seted)
        {
            Bodies.ChangeLenght(Bodies.N + 1);
        }
        else
        {
            Bodies.Seted = true;
        }
        Bodies.Massive[Bodies.N - 1] = Obj;
    }
Но если i или i2 не равны 0, то в этих элементе с таким номером хранится мусор.
John Prick
773 / 706 / 129
Регистрация: 27.07.2012
Сообщений: 2,022
Завершенные тесты: 3
21.08.2014, 23:50     Переопределение размера массива указателей #22
WinRar007, в обоих участках кода я так и не увидел, где создаётся твой динамический массив. Это во-первых. Во-вторых, насколько я помню, в самом начале твоего вопроса фигурировало
C++
1
2
N = 1;
        Massive = new TypeName*[N];
Чему равно N в том варианте, где, как ты говоришь, любой элемент, кроме 0го содержит мусор?

Добавлено через 1 минуту
ПС. Ну и до кучи. Зачем у тебя внутренними полями твоего класса-обёртки управляет внешний код?
Alex5
1039 / 702 / 102
Регистрация: 12.04.2010
Сообщений: 1,766
22.08.2014, 12:44     Переопределение размера массива указателей #23
Цитата Сообщение от WinRar007 Посмотреть сообщение
C++
1
CheckCollision(Settings.Time / loops, Bodies.Massive[i], Bodies.Massive[i2]);
Цитата Сообщение от John Prick Посмотреть сообщение
И что находится в этих элементах массива?
Цитата Сообщение от WinRar007 Посмотреть сообщение
Должен находится указатель, записанный этой функцией:
Может случиться, что эта функция запишет, не то что должна, а то, чему равен Obj Кстати, куда запишет - зависит от значения Bodies.N в момент вызова.


Цитата Сообщение от WinRar007 Посмотреть сообщение
C++
1
2
3
4
5
void AddToRander(Body *Obj)
 {
  ...
 Bodies.Massive[Bodies.N - 1] = Obj;
 }
WinRar007
1 / 1 / 0
Регистрация: 08.04.2014
Сообщений: 80
24.08.2014, 13:25     Переопределение размера массива указателей #24
John Prick,
Во первых, Massive = new TypeName*[N];
Динамический массив указателей.
Во вторых, если поменять N на, допустим, десять и заполнить все элементы, то проблема не исчезнет.
В третьих,
ПС. Ну и до кучи. Зачем у тебя внутренними полями твоего класса-обёртки управляет внешний код?
Что?
Может случиться, что эта функция запишет, не то что должна, а то, чему равен Obj Кстати, куда запишет - зависит от значения Bodies.N в момент вызова.
Тоже ничего не понял. Я вроде явно присваиваю указателю адрес... Или нет?

Добавлено через 5 минут
P.S. Сами объекты хранятся пока в статичном массиве.
Alex5
1039 / 702 / 102
Регистрация: 12.04.2010
Сообщений: 1,766
24.08.2014, 15:53     Переопределение размера массива указателей #25
Цитата Сообщение от WinRar007 Посмотреть сообщение
Но если i или i2 не равны 0, то в этих элементе с таким номером хранится мусор.
Раз хранится мусор, значит его туда записали. WinRar007, какой ещё ответ Вы хотите услышать?

Где у Вас в программе изменяются значения массива (в котором хранится мусор)?

Добавлено через 20 минут
Цитата Сообщение от WinRar007 Посмотреть сообщение
John Prick,
Во первых, Massive = new TypeName*[N];
Цитата Сообщение от John Prick Посмотреть сообщение
WinRar007, в обоих участках кода я так и не увидел, где создаётся твой динамический массив.
WinRar007, можно так переформулировать вопрос. Где в программе определяется переменная, имеющая тип DinamicMassive<...>?
WinRar007
1 / 1 / 0
Регистрация: 08.04.2014
Сообщений: 80
24.08.2014, 20:55     Переопределение размера массива указателей #26
Alex5,
Эмм... Мы о разных динамических массивах говорим?
Всё, понял.
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
private:
    DinamicMassive <Body> Bodies;
    int i = 0;
    int i2 = 0;
    void Joints(float T, Body *body1, Body *body2)
    {   
        if (body1 != body2)
        {
            if (body1->Dinamic)
            {
                if (Settings.Gravity)
                {
                    body1->AddForce(GravityJoint(body1, body2));
                }
                if (Settings.Magnet)
                {
                    body1->AddForce(MagnetJoint(body1, body2));
                }
                if (Settings.Elemental)
                {
                    body1->AddForce(ElementJoint(body1, body2));
                }
            }
        }
        body1->CalcVel(T);
    }
Раз хранится мусор, значит его туда записали.
Хорошо. Тогда почему этот код записал мусор (Указатель Obj не указывает на мусор).
C++
1
2
3
4
5
6
7
8
9
10
11
12
void AddToRander(Body *Obj)
    {
        if (Bodies.Seted)
        {
            Bodies.ChangeLenght(Bodies.N + 1);
        }
        else
        {
            Bodies.Seted = true;
        }
        Bodies.Massive[Bodies.N - 1] = Obj;
    }
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
template <class TypeName>
class DinamicMassive
{
public:
    TypeName **Massive;
    int N;
    bool Seted = false;
    DinamicMassive()
    {
        N = 1;
        Massive = new TypeName*[N];
    }
    ~DinamicMassive()
    {
        delete Massive;
    }
    void ChangeLenght(int NewLenght)
    {
        TypeName **Massive2 = new TypeName*[NewLenght];
        int i2 = 0;
        for (int i = 0; i < N; i++)
        {
            if (Massive[i + i2] != 0)
            {
                Massive2[i] = Massive[i + i2];
            }
            else
            {
                i2++;
            }
        }
        N = NewLenght;
        delete Massive;
        Massive = Massive2;
    }
private:
};
Добавлено через 1 минуту
Можно вашу реализацию динамического массива указателей на основе кучи с добавлением и удалением элементов?
Alex5
1039 / 702 / 102
Регистрация: 12.04.2010
Сообщений: 1,766
24.08.2014, 21:43     Переопределение размера массива указателей #27

Не по теме:

Определение поля Bodies состоит из одной строки. Зачем печатать 26+12+37 строк?


Причём на вопрос Вы так и не ответили. "Тип, класс", "переменная, объект".
Цитата Сообщение от Alex5 Посмотреть сообщение
Где в программе определяется переменная, имеющая тип DinamicMassive<...>?
Вопрос о переменной, объекте. Вы приводите определение класса.
DinamicMassive <Body> Bodies; является полем какого-то класса. Какие есть переменные(объекты) этого класса?

Добавлено через 10 минут
Цитата Сообщение от Alex5 Посмотреть сообщение
Раз хранится мусор, значит его туда записали.
Цитата Сообщение от WinRar007 Посмотреть сообщение
Хорошо. Тогда почему этот код записал мусор (Указатель Obj не указывает на мусор).
Другая возможная причина. Массив как-то изменился позже.
WinRar007
1 / 1 / 0
Регистрация: 08.04.2014
Сообщений: 80
25.08.2014, 09:06     Переопределение размера массива указателей #28
Alex5,
Я тут приведу весь код, чтоб больше вопросов подобного рода не возникало.
DinamicMassive

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
template <class TypeName>
class DinamicMassive
{
public:
    TypeName **Massive;
    int N;
    bool Seted = false;
    DinamicMassive()
    {
        N = 1;
        Massive = new TypeName*[N];
    }
    ~DinamicMassive()
    {
        delete Massive;
    }
    void ChangeLenght(int NewLenght)
    {
        TypeName **Massive2 = new TypeName*[NewLenght];
        int i2 = 0;
        for (int i = 0; i < N; i++)
        {
            if (Massive[i + i2] != 0)
            {
                Massive2[i] = Massive[i + i2];
            }
            else
            {
                i2++;
            }
        }
        N = NewLenght;
        delete Massive;
        Massive = Massive2;
    }
private:
};

Physics

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
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
#pragma once
#include "Vector2.hpp";
#include "DinamicMassive.cpp";
#include <iostream>;
#include <string>;
#include <random>;  
#include <math.h>;
 
using namespace sf;
using namespace std;
 
class Body
{
public:
    Vector2f Velocity;    // Тип - float
    Vector2f Force;       // Тип - float
    int ColType;
    float X, Y;
    float Mass;
    float R;
    float p = 1.0f;
    float Temp = 0.0f;
    float q = 0.0f;
    float e = 0.0f;
    bool Dinamic = true;
    bool Collided = false;
    bool Continue = false;
    Body()
    {
 
    }
    ~Body()
    {
 
    }
    void SetBody(Vector2f Vel, float Mas, float p1, int col, bool din)
    {
        Velocity = Vel;
        if (Mas == 0)
        {
            Mass = 0.0000001f;
        }
        else
        {
            Mass = Mas;
        }
        if (p1 == 0)
        {
            p = 1;
        }
        else
        {
            p = p1;
        }
        Dinamic = din;
        ColType = col;
        R = sqrt((Mass / p) / _Pi);
    }
    void AddVel(Vector2f Vel)
    {
        Velocity += Vel;
    }
    void AddForce(Vector2f force)
    {
        Force += force;
    }
    void CalcVel(float Time)
    {
        Velocity.x = Velocity.x + (Force.x*Time) / (Mass);
        Velocity.y = Velocity.y + (Force.y*Time) / (Mass);
        Force = { 0, 0 };
    }
    void SumB(Body *b2)
    {
        Velocity.x = ((Mass * Velocity.x) + (b2->Mass*b2->Velocity.x)) / (Mass + b2->Mass);
        Velocity.y = ((Mass * Velocity.y) + (b2->Mass*b2->Velocity.y)) / (Mass + b2->Mass);
        Mass = Mass + b2->Mass;
        p = sqrt(pow(p, 2) + pow(b2->p, 2));
        R = sqrt((Mass / p) / _Pi);
        X = X - b2->R * (X - b2->X) / (R + b2->R);
        Y = Y - b2->R * (Y - b2->Y) / (R + b2->R);
    }
    Vector2f Move(Vector2f Pos, float Time)
    {
        return(Pos + Velocity*Time);
    }
private:
};
 
class RenderSettings
{
public:
    float Time = 0.0f;
    bool Gravity = false;
    bool Magnet = true;
    bool Elemental = true;
    bool Rubber = false;
    bool Vectors = false;
    bool NoExit = true;
    int LBorder = 0;
    int RBorder = 0;
    int UBorder = 0;
    int DBorder = 0;
    float ForceScale = 1.0f;
    float Elk = 100.0f;
    float G = 0.0000000000667384f;
    float k = 8988000000.0f;
    void SetUp(bool G, bool R, bool V, bool X)
    {
        Gravity = G;
        Rubber = R;
        Vectors = V;
        NoExit = X;
    }
    void SetBorders(int L, int R, int U, int D)
    {
        LBorder = L;
        RBorder = R;
        UBorder = U;
        DBorder = D;
    }
private:
};
 
class PHYSICS
{
public:
    RenderSettings Settings;
    PHYSICS(float Time)
    {
        Settings.Time = Time;
    }
    ~PHYSICS()
    {
 
    }
    void render(float loops, bool joints, bool movement, bool collision)
    {
        if (loops == 0)
        {
            loops = 1;
        }
        for (int L = 0; L < loops; L++)
        {
            if (joints)
            {
                for (i = 0; i < Bodies.N; i++)
                {
                    for (i2 = 0; i2 < Bodies.N; i2++)
                    {
                        if (i != i2)
                        {
                            Joints(Settings.Time / loops, Bodies.Massive[i], Bodies.Massive[i2]);
                        }
                    }
                }
            }
            if (collision)
            {
                for (i = 0; i < Bodies.N; i++)
                {
                    for (i2 = 0; i2 < Bodies.N; i2++)
                    {
                        if (i != i2)
                        {
                            CheckCollision(Settings.Time / loops, Bodies.Massive[i], Bodies.Massive[i2]);
                        }
                    }
                }
            }
            if (movement)
            {
                for (i = 0; i < Bodies.N; i++)
                {
                    Movement(Settings.Time / loops, Bodies.Massive[i]);
                }
            }
        }
    }
    void AddToRander(Body *Obj)
    {
        if (Bodies.Seted)
        {
            Bodies.ChangeLenght(Bodies.N + 1);
        }
        else
        {
            Bodies.Seted = true;
        }
        Bodies.Massive[Bodies.N - 1] = Obj;
    }
    void DelFromRander(int Num)
    {
        Bodies.Massive[Num]->R = -(Bodies.Massive[Num]->R * 2);
        Bodies.Massive[Num]->Dinamic = false;
        Bodies.Massive[Num] = 0;
        Bodies.ChangeLenght(Bodies.N - 1);
    }
    Body *GetFromRender(int N1)
    {
        return(Bodies.Massive[N1]);
    }
    int GetNumFromRender(Body *b1)
    {
        int Num = 0;
        while (b1 != Bodies.Massive[Num])
        {
            Num++;
        }
        return(Num);
    }
    void StopObj()
    {
        for (i = 0; i < Bodies.N; i++)
        {
            Bodies.Massive[i]->Velocity = { 0, 0 };
            Bodies.Massive[i]->Force = { 0, 0 };
        }
    }
    Vector2f RubberJoint(float X, float X1, float Y, float Y1, float Div)
    {
        if (Div == 0)
        {
            Div = 1;
        }
        Div = Div / 10;
        Vector2f Vel;
        Vel.x = -(X - X1) / Div;        
        Vel.y = -(Y - Y1) / Div;
        return(Vel);
    }
    Vector2f MagnetJoint(Body *b1, Body *b2)
    {
        Vector2f Vel1;
        float Vel2;
        Vel2 = Settings.ForceScale * -1 * Settings.k * (b1->q*b2->q) / (pow(b1->X - b2->X, 2) + pow(b1->Y - b2->Y, 2));
        Vel1.x = (Vel2 / sqrt(pow((b2->X - b1->X), 2) + pow((b2->Y - b1->Y), 2)))*(b2->X - b1->X);
        Vel1.y = (Vel2 / sqrt(pow((b2->X - b1->X), 2) + pow((b2->Y - b1->Y), 2)))*(b2->Y - b1->Y);
        return(Vel1);
    }
    Vector2f ElementJoint(Body *b1, Body *b2)
    {
        Vector2f Vel1;
        float Vel2;
        float Vel3;
        Vel2 = Settings.ForceScale * pow(sqrt(b1->e*b2->e) / (sqrt(pow(b1->X - b2->X, 2) + pow(b1->Y - b2->Y, 2))), 6);
        Vel3 = Settings.ForceScale * pow(sqrt(b1->e*b2->e) / (sqrt(pow(b1->X - b2->X, 2) + pow(b1->Y - b2->Y, 2))), 12);
        Vel2 = Settings.Elk * (Vel3 - Vel2);
        Vel1.x = (Vel2 / sqrt(pow((b2->X - b1->X), 2) + pow((b2->Y - b1->Y), 2)))*(b2->X - b1->X);
        Vel1.y = (Vel2 / sqrt(pow((b2->X - b1->X), 2) + pow((b2->Y - b1->Y), 2)))*(b2->Y - b1->Y);
        return(Vel1);
    }
    Vector2f GravityJoint(Body *b1, Body *b2)
    {
        Vector2f Vel1;
        float Vel2;
        Vel2 = Settings.ForceScale * Settings.G * (b1->Mass*b2->Mass) / (pow(b1->X - b2->X, 2) + pow(b1->Y - b2->Y, 2));
        Vel1.x = (Vel2 / sqrt(pow((b2->X - b1->X), 2) + pow((b2->Y - b1->Y), 2)))*(b2->X - b1->X);
        Vel1.y = (Vel2 / sqrt(pow((b2->X - b1->X), 2) + pow((b2->Y - b1->Y), 2)))*(b2->Y - b1->Y);
        return(Vel1);
    }
private:
    DinamicMassive <Body> Bodies;
    int i = 0;
    int i2 = 0;
    void Joints(float T, Body *body1, Body *body2)
    {   
        if (body1 != body2)
        {
            if (body1->Dinamic)
            {
                if (Settings.Gravity)
                {
                    body1->AddForce(GravityJoint(body1, body2));
                }
                if (Settings.Magnet)
                {
                    body1->AddForce(MagnetJoint(body1, body2));
                }
                if (Settings.Elemental)
                {
                    body1->AddForce(ElementJoint(body1, body2));
                }
            }
        }
        body1->CalcVel(T);
    }
    void Movement(float T, Body *body1)
    {
        if (body1->Dinamic)
        {
            if (!body1->Continue)
            {
                body1->X = body1->Move({ body1->X, body1->Y }, T).x;
                body1->Y = body1->Move({ body1->X, body1->Y }, T).y;
                if (Settings.NoExit)
                {
                    if (body1->X >= Settings.RBorder)
                    {
                        body1->X = Settings.LBorder + 1;
                    }
                    if (body1->X <= Settings.LBorder)
                    {
                        body1->X = Settings.RBorder - 1;
                    }
                    if (body1->Y >= Settings.DBorder)
                    {
                        body1->Y = Settings.UBorder + 1;
                    }
                    if (body1->Y <= Settings.UBorder)
                    {
                        body1->Y = Settings.DBorder - 1;
                    }
                }
            }
            else
            {
                body1->Continue = false;
            }
        }
    }
    void CheckCollision(float T, Body *body1, Body *body2)смогу.
    {
        if (body1->ColType != 0 && body2->ColType != 0 && body1 != body2)
        {
            if (!body1->Continue && !body2->Continue)
            {
                float Length = 0.0f;
                float Radius = 0.0f;
                float Value = 0.0f;
                Vector2f Point1 = { body1->X, body1->Y };
                Vector2f Point2 = { body1->X + body1->Velocity.x*T,
                    body1->Y + body1->Velocity.y*T };
                Vector2f Point3 = { body2->X, body2->Y };
                Vector2f Point4 = { body2->X + body2->Velocity.x*T,
                    body2->Y + body2->Velocity.y*T };
                if (Point1.x > Point2.x)
                {
                    Value = Point1.x;
                    Point1.x = Point2.x;
                    Point2.x = Value;
                }
                if (Point1.y > Point2.y)
                {
                    Value = Point1.y;
                    Point1.y = Point2.y;
                    Point2.y = Value;
                }
                if (Point3.x > Point4.x)
                {
                    Value = Point3.x;
                    Point3.x = Point4.x;
                    Point3.x = Value;
                }
                if (Point3.y > Point4.y)
                {
                    Value = Point3.y;
                    Point3.y = Point4.y;
                    Point4.y = Value;
                }
                Point1.x = Point1.x - body1->R;
                Point2.x = Point2.x + body1->R;
                Point1.y = Point1.y - body1->R;
                Point2.y = Point2.y + body1->R;
 
                Point3.x = Point3.x - body2->R;
                Point4.x = Point4.x + body2->R;
                Point3.y = Point3.y - body2->R;
                Point4.y = Point4.y + body2->R;
                if ((Point3.x <= Point1.x && Point1.x <= Point4.x) || (Point1.x <= Point3.x && Point3.x <= Point2.x))
                {
                    if ((Point3.y <= Point1.y && Point1.y <= Point4.y) || (Point1.y <= Point3.y && Point3.y <= Point2.y))
                    {
                        Radius = body1->R + body2->R;
                        float speed = 0.0f;
                        if (abs(body1->Velocity.x*T) + abs(body2->Velocity.x*T)
                            > abs(body1->Velocity.y*T) + abs(body2->Velocity.y*T))
                        {
                            speed = abs(body1->Velocity.x*T) + abs(body2->Velocity.x*T);
                        }
                        else
                        {
                            speed = abs(body1->Velocity.y*T) + abs(body2->Velocity.y*T);
                        }
                        float DT = T * Radius / speed;
                        if (DT > T)
                        {
                            DT = T;
                        }
                        int Num = T / DT;
                        int Collided = 0;
                        for (float ii = 0; ii <= Num; ii++)
                        {
                            if (Collided == 0)
                            {
                                Length = sqrt(pow(body1->X - body2->X, 2)
                                    + pow(body1->Y - body2->Y, 2));
                                if (Length <= Radius)
                                {
                                    switch (body1->ColType)
                                    {
                                        case 1:
                                        {
                                            break;
                                        }
                                        case 2:
                                        {
                                            if (Collided != 1)
                                            {
                                                if (body1->Mass >= body2->Mass)
                                                {
                                                    body1->SumB(body2);
                                                    DelFromRander(i2);
                                                    Collided = 2;
 
                                                    i2--;
                                                    if (i > i2)
                                                    {
                                                        i--;
                                                    }
                                                }
                                                Movement(DT, body1);
                                                break;
                                            }
                                        }
                                        default:
                                        {
                                            break;
                                        }
                                    }
                                    switch (body2->ColType)
                                    {
                                        case 1:
                                        {
                                            break;
                                        }
                                        case 2:
                                        {
                                            if (Collided != 2)
                                            {
                                                if (body2->Mass > body1->Mass)
                                                {
                                                    body2->SumB(body1);
                                                    DelFromRander(i);
                                                    Collided = 1;
                                                    i--;
                                                    i2 = Bodies.N;
                                                }
                                                Movement(DT, body2);
                                                break;
                                            }
                                        }
                                        default:
                                        {
                                            break;
                                        }
                                    }
                                }
                            }
                            Movement(DT, body1);
                            Movement(DT, body2);
                        }
                        body1->Continue = true;
                        body2->Continue = true;
                    }
                }
            }
        }
    }
    void ColTypes(Body *body1, Body *body2, float DT)
    {
        if (body1->ColType == body2->ColType)
        {
            switch (body1->ColType)
            {
                case 1:
                {
                    Movement(DT, body1);
                    Movement(DT, body2);
                }
                case 2:
                {
                    if (body1->Collided)
                    {
                        if (body1->ColType == 2 && body2->ColType == 2)
                        {
                            if (body1->Mass <= body2->Mass)
                            {
                                body2->SumB(body1);
                                DelFromRander(GetNumFromRender(body1));
                            }
                            if (GetNumFromRender(body1) > GetNumFromRender(body2))
                            {
                                //i--;
                            }
                        }
                    }
                    default:
                    {
                        Movement(DT, body1);
                        Movement(DT, body2);
                    }
                }
            }
        }
    }
};
WinRar007
1 / 1 / 0
Регистрация: 08.04.2014
Сообщений: 80
25.08.2014, 09:07     Переопределение размера массива указателей #29
Main

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
#include <SFML/Graphics.hpp>;
#include <iostream>;
#include <string>;
#include <random>;
#include <math.h>;
#include <time.h>;
#include <stdio.h>;
#include <stdlib.h>; 
 
#include "Pragmas.cpp";
 
using namespace sf;
using namespace std;
 
ContextSettings settings;
 
int main()
{
    setlocale(LC_ALL, "Russian");
    cout << "SPACEv0.8.9" << endl << endl;
    cout << "*ВАЖНО*" << endl << endl;
    cout << "Для корректной работы программы переключите раскладку на английскую." << endl;
    cout << "После появления окна кликнете по нему, чтоб сфокусироваться на нём." << endl << endl;
    cout << "*УПРАВЛЕНИЕ*" << endl << "(Все буквы английские)" << endl << endl;
    cout << "P: Пауза" << endl;
    cout << "R: Остановить тела" << endl;
    cout << "G: Включить/выключить гравитацию" << endl;
    cout << "V: Включить/выключить вектора" << endl;
    cout << "S: Просчёт одной единицы времени" << endl;
    cout << "+/-: Увеличить/уменьшить скорость симуляции" << endl;
    cout << "ПКМ: Включить/выключить гравитацию курсора" << endl;
    cout << "СКМ: Приблизить/отдалить камеру" << endl << endl;
    float T = 1;
    if (T < 0.125f)
    {
        T = 0.125f;
    }
    Object Objects[100];
    PHYSICS World1(T);
    Game GUI(T, &Objects);
    World1.Settings.SetUp(false, false, false, true);
    World1.Settings.SetBorders(-100, 1124, -100, 868);
    //World1.Settings.SetBorders(256, 768, 192, 576);
    //VARS-----------------------------------------------------------
      //SFML:
        Clock clock;
        int X = (float)GUI.window.getSize().x;
        int Y = (float)GUI.window.getSize().y;
      //Other:
        int Time = 0;
        //bool Timer = false;
    //VARS-----------------------------------------------------------
    for (int i = 0; i < 100; i++)
    {
        srand(time(NULL)*rand());
        Objects[i].SetPosition(rand() % X, rand() % Y, false);
        World1.AddToRander(&Objects[i].body);
        GUI.AddToGRander(&Objects[i]);
    }
    GUI.MainLoop(&World1);
}

GUI

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
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
#pragma once
#include <SFML/Graphics.hpp>;
#include <SFML/OpenGL.hpp>;
#include <SFML/Audio.hpp>;
#include <iostream>;
#include <string>;
#include <random>;
#include <math.h>; 
 
#include "Physics.cpp";
 
using namespace sf;
using namespace std;
 
class Object
{
public:
    Body body;
    Vertex Vect[2];
    Object()
    {
        srand(time(NULL)*rand());
        body.SetBody({ 0.0, 0.0 }, (rand() % 10000) + 1000000000000, 50000000000, 2, true);
        /*if (Obj.body.Mass < 10 && Obj.GetRadius() < 5)
        {
            int Temp = Obj.body.Mass * 50 + Random(9000);
            int Temp2 = Temp / 1000;
        }*/
    }
    ~Object()
    {
 
    }
    CircleShape GetShape()
    {
        shape.setFillColor(Colour);
        return(shape);
    }
    void Resize(float DX, float DY)
    {
        Vector2f Scal;
        Scal.x = shape.getScale().x * DX;
        Scal.y = shape.getScale().y * DY;
        shape.setScale(Scal);
    }
    void SetScale(float X, float Y)
    {
        shape.setScale(Vector2f(X, Y));
    }
    void SetPosition(float x, float y, bool ShapeOnly)
    {
        if (!ShapeOnly)
        {
            body.X = x;
            body.Y = y;
        }
        shape.setPosition(x - body.R, y - body.R);
    }
    void SetRadius(float r, bool ShapeOnly)
    {
        if (!ShapeOnly)
        {
            body.R = r;
        }
        shape.setRadius(r);
    }
    void CalcVect()
    {
        Vector2f V = { body.X, body.Y };
        Vect[0] = Vertex(V);
        Vect[1] = Vertex(V + body.Velocity);
    }
private:
    CircleShape shape;
    Color Colour = Color::White;
};
 
class GameSettings
{
public:
    ContextSettings settings;
    Vector2f CameraPos = {0, 0};
    int SpawnMode;
    int CameraMoveR = 250;
    float Scale = 1;
    float Frames = 24;
    float Time = 1;
    int Interations = 1;
    bool Pause = true;
};
 
class Game
{
public:
    GameSettings Settings;
    RenderWindow window;
    Font font;
    Text Messages;
    Texture background;
    Sprite sprite;
    Music music;
    Body Cursor;
    bool Curs = true;
    Object (*Arr)[100];
    Game(float Time, Object (*Array)[100])
    {
        Arr = Array;
        Settings.Time = Time;
        Settings.Interations = Settings.Time * 10;
        cout << "Количество временных интераций: " << Settings.Interations << endl;
        float A;
        cout << "Введите массу курсора: ";
        cin >> A;
        Cursor.SetBody({ 0.0, 0.0 }, A, 1, false, false);
        Settings.settings.antialiasingLevel = 8;
        Settings.settings.depthBits = 24;
        Settings.settings.stencilBits = 8;
        Settings.settings.majorVersion = 3;
        Settings.settings.minorVersion = 0;
        window.create(VideoMode(1024, 768), "SPACE", Style::Default, Settings.settings);
        window.setFramerateLimit(Settings.Frames);
        font.loadFromFile("arial.ttf");
        Messages.setFont(font);
        Messages.setCharacterSize(24);
        Messages.setColor(Color::White);
        Messages.setStyle(Text::Bold);
        background.loadFromFile("space.png");
        background.setSmooth(true);
        sprite.setTexture(background);
        sprite.setTextureRect(IntRect(0, 0, 1280, 1024));
        music.openFromFile("music.ogg");
        music.setLoop(true);
        music.play();
        Settings.CameraPos.x = window.getSize().x / 2;
        Settings.CameraPos.y = window.getSize().y / 2;
    }
    ~Game()
    {
 
    }
    void MainLoop(PHYSICS *World1)
    {
        while (window.isOpen())
        {
            Event event;
            while (window.pollEvent(event))
            {
                switch (event.type)
                {
                    case Event::MouseButtonPressed:
                    {
                        /*if (event.mouseButton.button == Mouse::Left && N < 100)
                        {
                            cout << "12345" << endl;
                            srand(time(NULL)*rand());
                            Arr[N]->SetPosition(Mouse::getPosition().x, Mouse::getPosition().y);
                            World1->AddToRander(&Arr[N]->body);
                            AddToGRander(Arr[N]);
                        }*/
                        if (event.mouseButton.button == Mouse::Right)
                        {
                            if (Curs)
                            {
                                World1->AddToRander(&Cursor);
                                Curs = false;
                                cout << "Гравитация курсора включена" << endl;
                            }
                            else
                            {
                                World1->DelFromRander(World1->GetNumFromRender(&Cursor));
                                Curs = true;
                                cout << "Гравитация курсора выключена" << endl;
                            }
                        }
                        if (event.mouseButton.button == Mouse::Left)
                        {
 
                        }
                        break;
                    }
                    case Event::MouseWheelMoved:
                    {
                        if (event.mouseWheel.delta < 0)
                        {
                            Settings.Scale = Settings.Scale / 1.2f;
                        }
                        if (event.mouseWheel.delta > 0)
                        {
                            Settings.Scale = Settings.Scale * 1.2f;
                        }
                        break;
                    }
                    case Event::MouseMoved:
                    {
                        break;
                    }
                    case Event::Closed:
                    {
                        music.stop();
                        window.close();
                        exit(0); //Exit by user
                        break;
                    }
                    case Event::KeyPressed:
                    {
                        switch (event.key.code)
                        {
                            case Keyboard::Up:
                            {
                                Settings.CameraPos.y = Settings.CameraPos.y - 5 / Settings.Scale;
                                break;
                            }
                            case Keyboard::Down:
                            {
                                Settings.CameraPos.y = Settings.CameraPos.y + 5 / Settings.Scale;
                                break;
                            }
                            case Keyboard::Left:
                            {
                                Settings.CameraPos.x = Settings.CameraPos.x - 5 / Settings.Scale;
                                break;
                            }
                            case Keyboard::Right:
                            {
                                Settings.CameraPos.x = Settings.CameraPos.x + 5 / Settings.Scale;
                                break;
                            }
                            case Keyboard::R:
                            {
                                World1->StopObj();
                                break;
                            }
                            case Keyboard::G:
                            {
                                if (World1->Settings.Gravity)
                                {
                                    World1->Settings.Gravity = false;
                                }
                                else
                                {
                                    World1->Settings.Gravity = true;
                                }
                                break;
                            }
                            case Keyboard::F:
                            {
                                if (World1->Settings.Rubber)
                                {
                                    World1->Settings.Rubber = false;
                                }
                                else
                                {
                                    World1->Settings.Rubber = true;
                                }
                                break;
                            }
                            case Keyboard::V:
                            {
                                if (World1->Settings.Vectors)
                                {
                                    World1->Settings.Vectors = false;
                                }
                                else
                                {
                                    World1->Settings.Vectors = true;
                                }
                                break;
                            }
                            case Keyboard::P:
                            {
                                if (Settings.Pause)
                                {
                                    Settings.Pause = false;
                                }
                                else
                                {
                                    Settings.Pause = true;
                                }
                                break;
                            }
                            case Keyboard::S:
                            {
                                if (!Settings.Pause)
                                {
                                    Settings.Pause = true;
                                }
                                Cursor.X = (float)Mouse::getPosition(window).x;
                                Cursor.Y = (float)Mouse::getPosition(window).y;
                                World1->render(Settings.Interations, true, true, true);
                                GraphRender(&window, World1);
                                window.display();
                                break;
                            }
                            case Keyboard::Add:
                            {
                                if (Settings.Time / 2 > 0.4f)
                                {
                                    Settings.Time = Settings.Time / 4;
                                    World1->Settings.Time = 1 / Settings.Time;
                                    Settings.Interations = ceil(2 * Settings.Frames / Settings.Time);
                                }
                                /*else
                                {
                                    Settings.Time = Settings.Time / 4;
                                    World1->Settings.Time = 1 / Settings.Time;
                                    Settings.Interations = 1;
                                }*/
                                break;
                            }
                            case Keyboard::Subtract:
                            {
                                if (Settings.Time >= 0.4f)
                                {
                                    Settings.Time = Settings.Time * 4;
                                    World1->Settings.Time = 1 / Settings.Time;
                                    Settings.Interations = ceil(2 * Settings.Frames / Settings.Time);
                                }
                                /*else
                                {
                                    Settings.Time = Settings.Time * 4;
                                    World1->Settings.Time = 1 / Settings.Time;
                                    Settings.Interations = 1;
                                }*/
                                break;
                            }
                            default:
                            {
                                break;
                            }
                        }
                        break;
                    }
                    case Event::Resized:
                    {
                        window.setSize(sf::Vector2u(1024, 768));
                        break;
                    }
                    default:
                    {
                        break;
                    }
                }
            }
            if (sqrt(pow(float(window.getSize().x) / 2 - float(Mouse::getPosition(window).x), 2)
                + pow(float(window.getSize().y / 2) - float(Mouse::getPosition(window).y), 2))
                > float(window.getSize().y) / 2 - Settings.CameraMoveR)
            {
                float Vel = -5.0f / Settings.Scale * sqrt(pow(float(window.getSize().x) / 2 - Mouse::getPosition(window).x, 2)
                    + pow(float(window.getSize().y) / 2 - Mouse::getPosition(window).y, 2)) / 400;
                float DelX = (Vel / sqrt(pow(float(window.getSize().x) / 2 - Mouse::getPosition(window).x, 2)
                    + pow(float(window.getSize().y) / 2 - Mouse::getPosition(window).y, 2)))
                    *(float(window.getSize().x) / 2 - Mouse::getPosition(window).x);
                float DelY = (Vel / sqrt(pow(float(window.getSize().x) / 2 - Mouse::getPosition(window).x, 2)
                    + pow(float(window.getSize().y) / 2 - Mouse::getPosition(window).y, 2)))
                    *(float(window.getSize().y) / 2 - Mouse::getPosition(window).y);
                Settings.CameraPos.x = Settings.CameraPos.x + DelX;
                Settings.CameraPos.y = Settings.CameraPos.y + DelY;
            }
            window.clear(Color::Black);
            sprite.setPosition((float)((1024.0f - Mouse::getPosition(window).x) / 20 - 128),
                (float)((0.0f - (Mouse::getPosition(window).y) / 20 - 128)));
            //window.draw(sprite);
            Messages.setPosition(0, 0);
            if (Settings.Pause)
            {
                Messages.setString(L"Нажмите [P] чтоб продолжть");
            }
            else
            {
                Messages.setString(L"Нажмите [P] для паузы");
                Cursor.X = (float)Mouse::getPosition(window).x;
                Cursor.Y = (float)Mouse::getPosition(window).y;
                World1->render(Settings.Interations, true, true, true);
            }
            window.draw(Messages);
            GraphRender(&window, World1);
            window.display();
        }
    }
    void AddToGRander(Object *Str)
    {
        if (N < 100)
        {
            Objects[N] = Str;
            N++;
        }
    }
    void DelFromGRander(int i)
    {
        while (i != N)
        {
            Objects[i] = Objects[i + 1];
            i++;
        }
        N--;
    }
    Object *GetFromGRender(int N1)
    {
        return(Objects[N1]);
    }
private:
    int N = 0;
    Object *Objects[100];
    void GraphRender(RenderWindow *window, PHYSICS *World1)
    {
        for (int i = 0; i < N; i++)
        {
            if (Objects[i]->body.R < 0)
            {
                Objects[i]->~Object();
                DelFromGRander(i);
                i--;
                continue;
            }
            Objects[i]->SetRadius(Objects[i]->body.R, true);
            Objects[i]->SetScale(Settings.Scale, Settings.Scale);
            Objects[i]->SetPosition(Settings.Scale * (Objects[i]->body.X - Settings.CameraPos.x) + (window->getSize().x / 2),
                (Settings.Scale * (Objects[i]->body.Y - Settings.CameraPos.y) + (window->getSize().y / 2)), true);
            window->draw(Objects[i]->GetShape());
            if (World1->Settings.Vectors)
            {
                Objects[i]->CalcVect();
                window->draw(Objects[i]->Vect, 2, Lines);
            }
        }
    }
};

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

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
#pragma comment(lib, "sfml-graphics")
#pragma comment(lib, "sfml-graphics-d")
#pragma comment(lib, "sfml-graphics-s")
#pragma comment(lib, "sfml-graphics-s-d")
#pragma comment(lib, "sfml-audio")
#pragma comment(lib, "sfml-audio-d")
#pragma comment(lib, "sfml-audio-s")
#pragma comment(lib, "sfml-audio-s-d")
#pragma comment(lib, "sfml-main")
#pragma comment(lib, "sfml-main-d")
#pragma comment(lib, "sfml-network")
#pragma comment(lib, "sfml-network-d")
#pragma comment(lib, "sfml-network-s")
#pragma comment(lib, "sfml-network-s-d")
#pragma comment(lib, "sfml-system")
#pragma comment(lib, "sfml-system-d")
#pragma comment(lib, "sfml-system-s")
#pragma comment(lib, "sfml-system-s-d")
#pragma comment(lib, "sfml-window")
#pragma comment(lib, "sfml-window-d")
#pragma comment(lib, "sfml-window-s")
#pragma comment(lib, "sfml-window-s-d")
#pragma comment(lib, "box2d")
 
#include "Physics.cpp";
#include "GUI.cpp";


Добавлено через 45 секунд
P.S. Опять же, можно ваше решение данной задачи? Это может сильно сэкономить время.
Alex5
1039 / 702 / 102
Регистрация: 12.04.2010
Сообщений: 1,766
25.08.2014, 19:25     Переопределение размера массива указателей #30
Цитата Сообщение от WinRar007 Посмотреть сообщение
можно ваше решение данной задачи? Это может сильно сэкономить время

Не по теме:

WinRar007, сильно ли это сэкономит моё время.




Цитата Сообщение от WinRar007 Посмотреть сообщение
только к нулевому элементу. Про другие ругается, что не может по такому адресу обратиться?
WinRar007, речь идёт о массиве World1.Bodies.Massive[] ? Где в программе изменяются (могут измениться) элементы этого массива?

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
template <class TypeName> class DinamicMassive
{
public:    TypeName **Massive;
...
};
 
 
class PHYSICS
{
private:    DinamicMassive <Body> Bodies;
...
};
 
int main()
{
...
PHYSICS World1(.);
...
Game GUI( ... );
...
GUI.MainLoop(&World1);
}
WinRar007
1 / 1 / 0
Регистрация: 08.04.2014
Сообщений: 80
25.08.2014, 19:45     Переопределение размера массива указателей #31
WinRar007, сильно ли это сэкономит моё время.
Возможно.
WinRar007, речь идёт о массиве World1.Bodies.Massive[] ? Где в программе изменяются (могут измениться) элементы этого массива?
Да, о нём. Везде, где подключен файл с кодом класса.
Iksyara
0 / 0 / 0
Регистрация: 03.11.2014
Сообщений: 3
03.11.2014, 06:06     Переопределение размера массива указателей #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
#pragma once
#include <Windows.h>
 
template<class T>
class Massive
{
public:
    Massive()
    {
        m_count = 0;
        m_massive = NULL;
    }
    ~Massive()
    {
        RemoveAll();
    }
    void Add(T* data)
    {
        T** temp = new T*[m_count+1];
 
        for(int i = 0; i < m_count; i++)
            temp[i] = m_massive[i];
 
        temp[m_count] = new T;
        *temp[m_count] = *data;
        m_count++;
 
        delete m_massive;
        m_massive = temp;
    }
    void Add(T* data, int id)
    {
        if(id < 0 || id >= m_count) return;
 
        T** temp = new T*[m_count+1];
 
        for(int i = 0; i < id; i++)
            temp[i] = m_massive[i];
 
        temp[id] = new T;
        *temp[id] = *data;
 
        for(int i = id; i < m_count; i++)
            temp[i+1] = m_massive[i];
 
        m_count++;
 
        delete m_massive;
        m_massive = temp;
    }
    void Remove(int id)
    {
        if(id < 0 || id >= m_count) return;
 
        T** temp = new T*[m_count-1];
 
        for(int i = 0, j = 0; i < m_count-1; i++, j++)
        {
            if(j == id) j++;
            temp[i] = m_massive[j];
        }
 
        delete m_massive[id];
        m_count--;
 
        delete m_massive;
        m_massive = temp;
    }
    void RemoveAll()
    {
        for(int i = 0; i < m_count; i++)
            delete m_massive[i];
        delete m_massive;
 
        m_massive = NULL;
        m_count = 0;
    }
    void Swap(int id1, int id2)
    {
        T data;
 
        data = *m_massive[id1];
        *m_massive[id1] = *m_massive[id2];
        *m_massive[id2] = data;
    }
    T* operator[](int id) const
    {
        if(id < 0 || id >= m_count) return NULL;
        return m_massive[id];
    }
    int Count() const
    {
        return m_count;
    }
private:
    int         m_count;
    T**         m_massive;
};
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
#include <iostream>
#include "Massive.h"
 
struct s_data
{
    wchar_t name[255];
};
 
Massive<s_data> mass;
 
void Print()
{
    for(int i = 0; i < mass.Count(); i++)
        std::wcout << i << L" - " << mass[i]->name << std::endl;
}
 
int main()
{
    wchar_t buff[255];
    s_data data;
 
    std::wcout << L"*****|dobavili 5 chelovek|*****" << std::endl;
    wcscpy_s(data.name, L"Petrov");     mass.Add(&data);
    wcscpy_s(data.name, L"Sidorov");    mass.Add(&data);
    wcscpy_s(data.name, L"Ivanov");     mass.Add(&data);
    wcscpy_s(data.name, L"Smirnov");    mass.Add(&data);
    wcscpy_s(data.name, L"Morozov");    mass.Add(&data);
    Print();
    std::wcout << L"*****|Ubrali Sidorova|*****" << std::endl;
    mass.Remove(1);
    Print();
    std::wcout << L"*****|Postavili Sokolova pered Smirnovim|*****" << std::endl;
    wcscpy_s(data.name, L"Sokolov");    mass.Add(&data, 2);
    Print();
    std::wcout << L"*****|Pomenyali mestami Sokolova i Smirnova|*****" << std::endl;
    mass.Swap(2, 3);
    Print();
    std::wcout << L"*****|Udalili vseh|*****" << std::endl;
    mass.RemoveAll();
    Print();
 
    while(true)
    {
        std::wcout << L">:"; std::wcin >> buff;
        if(!wcscmp(buff, L"quit")) break;
    }
    return 0;
}
Добавлено через 14 минут
Со связанными списками еще лучше получится) но тут вроде как, о переопределении размера массива указателей с сохранением данных))))
TheCalligrapher
С чаем беда...
Эксперт CЭксперт С++
3635 / 1910 / 503
Регистрация: 18.10.2014
Сообщений: 3,478
03.11.2014, 07:06     Переопределение размера массива указателей #33
Цитата Сообщение от Iksyara Посмотреть сообщение
Пришлось писать вот это
1. Везде используется 'delete m_massive' вместо правильного 'delete[] m_massive'.
2. Функция 'void Add(T* data, int id)' безо всякой видимой причины отказывается добавлять элемент сразу за последним. А ведь достаточно просто исправить первый if

C++
1
if(id < 0 || id > m_count) return;
3. Нет смысла реализовывать функцию 'void Add(T* data)' "с нуля", когда рядом лежит готовая 'void Add(T* data, int id)'. Надо лишь разрешить пункт 2
4. По какой-то непонятной причине функция 'void Add(T* data, int id)' написана через два цикла (цикл "до" и цикл "после"), что является правильной идеей. Но при этом функция 'void Remove(int id)' написана через один цикл с внутренним 'if'. Как будто два разных человека писало...
5. Функция добавления элемента почему-то делает двухшаговое создание нового элемента (конструирование пустого+присваивание)

C++
1
2
temp[m_count] = new T;
*temp[m_count] = *data;
вместо того, чтобы просто воспользоваться конструктором копирования и сделать все за один шаг

C++
1
temp[m_count] = new T(*data);
6. Не понятно почему используется знаковый тип в качестве индекса массива. Это лишь создает необходимость проверки на отрицательный индекс. Можно было использовать беззнаковый тип и такую проверку не делать.

7. Метод 'Swap' несколько удивляет своей реализацией. Почему он обменивает содержимое объектов, а не просто указатели? Возникает вопрос: а нафига вообще данный массив реализован внутренне как массив указателей (а не массив самих объектов), если предоставляемые такой реализацией уникальные оптимизационные возможности не используются? Опять же, не используется конструктор копирования.

8. Так тщательно выполняемая везде проверка правильности индексов почему-то напрочь отсутствует в методе 'Swap'.
Iksyara
0 / 0 / 0
Регистрация: 03.11.2014
Сообщений: 3
04.11.2014, 00:26     Переопределение размера массива указателей #34
TheCalligrapher,

void Add(T* data) я использовал просто для добавления в конец массива. потом пришлось написать void Add(T* data, int id) для вставки в середину. руки еще не дошли объединить их вместе)

про delete[] m_massive знаю, мой косяк) хотя...утечки памяти вроде как нет) проверяю через вот эту хрень _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);

да и смысл был показать как переопределить массив указателей)

temp[m_count] = new T(*data); ну...я только учусь и приходиться делать шаг за шагом.

и спасибо за указание ошибок, будем исправлять. про swap я знаю. если бы еще кто глянул на мой связной список, там наверное ошибок еще больше))))
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
05.11.2014, 23:57     Переопределение размера массива указателей
Еще ссылки по теме:

Разыменовывание массива указателей - C++
Здравствуйте. Если просто создать статический массив char a = {'s', ' t','r','i','n','g'}; Объявить на него указатель char* v = a; и...

Рисунок в C++ с использованием массива и указателей - C++
Создать одномерный символьный массив размерностью N*N (N - const). Заполнить его содержимое пробелами &quot;_&quot;. Заполнить его содержимое при...

Заполнение массива с использованием указателей - C++
Необходимо заполлнить массив a с использовнием ничего не возвращающей функии и указателей. Однако происходить только заполнение всех...

Объявление динамического массива указателей - C++
как объявить динамический массив указателей? я знаю что обычный динамический массив записывать, например, так: ... char *array =...

Обработка массива с использованием указателей - C++
Помогите пожалуйста изменить программу, чтобы она была с динамическим массивом Вот условие задачи: В одномерном массиве из N...


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

Или воспользуйтесь поиском по форуму:
Iksyara
0 / 0 / 0
Регистрация: 03.11.2014
Сообщений: 3
05.11.2014, 23:57     Переопределение размера массива указателей #35
Все исправил. Спасибо за тыканье носом в мои ошибки)))

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
#pragma once
#include <Windows.h>
 
template <class T>
class cMass
{
public:
    cMass()
    {
        m_count = 0;
        m_mass = NULL;
    }
    ~cMass()
    {
        RemoveAll();
    }
    void Add(T* data, int id = -1)
    {
        int iID = id;
        if(id < 0 || id > m_count) iID = m_count;
 
        T** temp = new T*[m_count+1];
 
        for(int i = 0; i < iID; i++)
            temp[i] = m_mass[i];
 
        temp[iID] = new T(*data);
 
        for(int i = iID; i < m_count; i++)
            temp[i+1] = m_mass[i];
 
        m_count++;
        delete [] m_mass;
        m_mass = temp;
    }
    int Remove(int id)
    {
        if(id < 0 || id >= m_count) return 1;
 
        T** temp = new T*[m_count-1];
 
        for(int i = 0; i < id; i++)
            temp[i] = m_mass[i];
 
        for(int i = id; i < m_count-1; i++)
            temp[i] = m_mass[i+1];
 
        delete m_mass[id];
        m_count--;
 
        delete [] m_mass;
        m_mass = temp;
 
        return 0;
    }
    void RemoveAll()
    {
        for(int i = 0; i < m_count; i++)
            delete m_mass[i];
        delete [] m_mass;
 
        m_mass = NULL;
        m_count = 0;
    }
    int Swap(int id1, int id2)
    {
        if(id1 < 0 || id1 >= m_count) return 1;
        if(id2 < 0 || id2 >= m_count) return 2;
 
        T* temp = m_mass[id1];
        m_mass[id1] = m_mass[id2];
        m_mass[id2] = temp;
 
        return 0;
    }
    T* operator[](int id) const
    {
        if(id < 0 || id >= m_count) return NULL;
        return m_mass[id];
    }
    int Count()
    {
        return m_count;
    }
private:
    int         m_count;
    T**         m_mass;
};
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
#include <iostream>
#include "cMass.h"
 
struct s_data
{
    wchar_t     name[255];
};
 
cMass<s_data> mass;
 
void Print()
{
    for(int i = 0; i < mass.Count(); i++)
        std::wcout << i << L" - " << mass[i]->name << std::endl;
}
 
int main()
{
    wchar_t buff[255];
    s_data data;
 
    std::wcout << L"*****|dobavili 5 chelovek|*****" << std::endl;
    wcscpy_s(data.name, L"Petrov");     mass.Add(&data);
    wcscpy_s(data.name, L"Sidorov");    mass.Add(&data);
    wcscpy_s(data.name, L"Ivanov");     mass.Add(&data);
    wcscpy_s(data.name, L"Smirnov");    mass.Add(&data);
    wcscpy_s(data.name, L"Morozov");    mass.Add(&data);
    Print();
    std::wcout << L"*****|Ubrali Sidorova|*****" << std::endl;
    mass.Remove(1);
    Print();
    std::wcout << L"*****|Postavili Sokolova pered Smirnovim|*****" << std::endl;
    wcscpy_s(data.name, L"Sokolov");    mass.Add(&data, 2);
    Print();
    std::wcout << L"*****|Pomenyali mestami Sokolova i Smirnova|*****" << std::endl;
    mass.Swap(2, 3);
    Print();
    std::wcout << L"*****|Udalili vseh|*****" << std::endl;
    mass.RemoveAll();
    Print();
 
    while(true)
    {
        std::wcout << L">:"; std::wcin >> buff;
        if(!wcscmp(buff, L"quit")) break;
    }
 
    return 0;
}
Yandex
Объявления
05.11.2014, 23:57     Переопределение размера массива указателей
Ответ Создать тему
Опции темы

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