Поэлементно просуммировать два динамических двумерных массива

@Nuril · Регистрация: 07.11.2018

Студворк — интернет-сервис помощи студентам

Здравствуйте, у меня такое задание:
Написать программу, которая поэлементно суммирует два динамических двумерных массива, заполненных случайными числами и сохраняет результат в третьем массиве. Размеры исходных массивов задаются пользователем.

Такой вопрос я делаю программу и судя по "Размеры исходных массивов задаются пользователем" должна ли программа работать правильно при вводе размеров к примеру 4 5 и 6 2?
Если да есть ли способ определить в каком из массивов есть символ? ptr3[i][j] = (ptr[i][j] < ptr2[i][j]) ? (ptr2[i][j]) : (ptr[i][j]); Мой вариант не работает.

Добавлено через 7 минут
Кажется я сам нашел решение своего вопроса.
ptr3[i][j] = (COLUMN < COLUMN2) ? (ptr2[i][j]) : (ptr[i][j]);

@zss · 20.08.2019, 07:06

C++
1
2
3
4
5
int N=min(ROW,ROW2);
int M=min(COLUMN , COLUMN2);
for(int i=0;i<N;i++)
  for(int j=0;j<M;j++)
    ptr3[i][j] =ptr2[i][j]+ptr[i][j];

@Nuril · 20.08.2019, 07:15 **[ТС]**

Сообщение от zss

int N=min(ROW,ROW2);

На сколько я понял правильно суммировать числа до минимального размера из обоих массивов?

Или же нет тогда почему мне программа в отмеченном месте выдаёт ошибку хотя там есть число?

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
///----------------------------------------------------------------------------|
///Тема: «Многомерные динамические массивы»
///Задания для самостоятельной работы #4.
///----------------------------------------------------------------------------:
#include <iostream>
#include <ctime>
 
using namespace std;
 
#define FORi(n) for(int i = 0; i < n; ++i)
#define FORj(n) for(int j = 0; j < n; ++j)
///----------------------------------------------------------------------------|
/// Создание двумерного массива.
///----------------------------------------------------------------------------:
int** create_matrix(int row, int column)
{
    int** m;
    m = new int* [row];
    FORi(row)
    {
        m[i] = new int[column];
    }
    return m;
}
 
///----------------------------------------------------------------------------|
/// Удаление двумерного массива.
///----------------------------------------------------------------------------:
void delete_matrix(int**& m, int row)
{
    FORi(row)
    {
        delete[] m[i];
    }
    delete[] m;
    m = NULL;
}
 
///----------------------------------------------------------------------------|
/// Вывод двумерного массива на экран.
///----------------------------------------------------------------------------:
void show_matrix(int** ptr, int ROW, int COLUMN)
{
    if (ptr == NULL) return;
    FORi(ROW)
    {
        FORj(COLUMN)
        {
            cout << ptr[i][j] << " ";
        }
        cout << std::endl;
    }
    cout << std::endl;
}
void Summation(int** ptr, int**& ptr2, int ROW, int COLUMN, int ROW2, int COLUMN2);
 
///----------------------------------------------------------------------------|
/// Старт.
///----------------------------------------------------------------------------:
int main()
{
    srand(time(NULL));
///----------------------------------------------------------------------------|
/// Задание 4
///----------------------------------------------------------------------------:
 
    int ROW, COLUMN;
    cin >> ROW >> COLUMN;
    int** ptr = create_matrix(ROW, COLUMN);
    FORi(ROW)
    {
        FORj(COLUMN)
        {
            ptr[i][j] = rand() % 5;
        }
    }
    int ROW2, COLUMN2;
    cin >> ROW2 >> COLUMN2;
    int** ptr2 = create_matrix(ROW2, COLUMN2);
    FORi(ROW2)
    {
        FORj(COLUMN2)
        {
            ptr2[i][j] = rand() % 5;
        }
    }
    cout <<
        "\n///-------------------------|" <<
        "\n/// Data matrix 1           |" <<
        "\n///-------------------------:\n";
    show_matrix(ptr, ROW, COLUMN);
    cout <<
        "\n///-------------------------|" <<
        "\n/// Data matrix 2           |" <<
        "\n///-------------------------:\n";
    show_matrix(ptr2, ROW2, COLUMN2);
 
    Summation(ptr, ptr2, ROW, COLUMN, ROW2, COLUMN2);
 
 
 
 
 
 
 
    cin.get();
    return 0;
}
 
///----------------------------------------------------------------------------|
/// Суммирование многомерных динамических массивов.
///----------------------------------------------------------------------------:
void Summation(int** ptr, int**& ptr2, int ROW, int COLUMN, int ROW2, int COLUMN2)
{
    int ROW3, COLUMN3;
    (ROW > ROW2) ? (ROW3 = ROW) : (ROW3 = ROW2);
    (COLUMN > COLUMN2) ? (COLUMN3 = COLUMN) : (COLUMN3 = COLUMN2);
    int** ptr3 = create_matrix(ROW3, COLUMN3);
    int i,j;
    for (i = 0; i < ROW3 && i < ROW && i < ROW2; i++)
    {
        for (j=0; j < COLUMN3 && j < COLUMN && j < COLUMN2; j++)
        {
            ptr3[i][j] = ptr2[i][j] + ptr[i][j];
            //cout << ptr3[i][j] << " ";
        }
        for (; j < COLUMN3; j++)
        {
            ptr3[i][j] = (COLUMN < COLUMN2) ? (ptr2[i][j]) : (ptr[i][j]);
            //cout << ptr3[i][j] << " ";
        }
    }
    for (;i < ROW3;i++)
    {
        for (j=0;j < COLUMN3; j++)
        {
            ptr3[i][j] = (COLUMN < COLUMN2) ? (ptr2[i][j]) : (ptr[i][j]); // На данном моменте ошибка
            //cout << ptr3[i][j] << " ";
        }
    }
    cout <<
        "\n///-------------------------|" <<
        "\n/// Result matrix           |" <<
        "\n///-------------------------:\n";
    show_matrix(ptr3, ROW3, COLUMN3);
}

@zss · 20.08.2019, 07:39

Сообщение от Nuril

(ROW > ROW2) ? (ROW3 = ROW) : (ROW3 = ROW2);
(COLUMN > COLUMN2) ? (COLUMN3 = COLUMN) : (COLUMN3 = COLUMN2);

Вы выбираете большие индексы, а надо меньшие.

C++
1
2
ROW3 = ROW < ROW2  ?  ROW : ROW2;
COLUMN3 = COLUMN < COLUMN2  ?  COLUMN  : COLUMN2;

А ежели Вам надо сохранить максимально все элементы, то лучше сделать так.
1. Выделяете память по максимуму (как у Вас сделано).
2. Копируете всю первую матрицу в ptr3.
3. Копируете всю вторую матрицу поверх первой в ptr3.
4. суммируете первую со второй в области их пересечения.

@Nuril · 20.08.2019, 12:54 **[ТС]**

Сообщение от zss

А ежели Вам надо сохранить максимально все элементы, то лучше сделать так.
1. Выделяете память по максимуму (как у Вас сделано).
2. Копируете всю первую матрицу в ptr3.
3. Копируете всю вторую матрицу поверх первой в ptr3.
4. суммируете первую со второй в области их пересечения

Да, сохранить нужно было все элементы, теперь понял как сделать менее затратно чем у меня. Спасибо.

Добавлено через 4 часа 52 минуты
А ещё такой вопрос как выводить максимально все элементы без мусора?
Я пытался сделать вот такой вывод но он не работает:

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
///----------------------------------------------------------------------------|
/// Вывод двумерного массива V2 на экран.
///----------------------------------------------------------------------------:
void show_matrix_v2(int** ptr, int ROW, int COLUMN, int ROW2, int COLUMN2, int ROW3, int COLUMN3)
{
    if (ptr == NULL) return;
    int i = 0;
    for (; i < ROW3 && i < ROW && i < ROW2; i++)
    {
        FORj(COLUMN3)
        {
            cout << ptr[i][j] << " ";
        }
        cout << endl;
    }
    if (COLUMN < COLUMN2) 
    {
        int t = (COLUMN < COLUMN2) ? (COLUMN2) : (COLUMN);
        for (; i < ROW3; i++)
        {
            for (int j = 0; j < t; j++)
            {
                cout << ptr[i][j] << " ";
            }
            cout << endl;
        }
    }
    else
    {
        int t = (COLUMN < COLUMN2) ? (COLUMN2) : (COLUMN);
        for (; i < ROW3; i++)
        {
            for (int j = 0; j < t; j++)
            {
                cout << ptr[i][j] << " ";
            }
            cout << endl;
        }
    }
}

Само задание.

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
///----------------------------------------------------------------------------|
///Тема: «Многомерные динамические массивы»
///Задания для самостоятельной работы #4.
///----------------------------------------------------------------------------:
 
 
#include <iostream>
#include <ctime>
 
using namespace std;
 
#define FORi(n) for(int i = 0; i < n; ++i)
#define FORj(n) for(int j = 0; j < n; ++j)
///----------------------------------------------------------------------------|
/// Создание двумерного массива.
///----------------------------------------------------------------------------:
int** create_matrix(int row, int column)
{
    int** m;
    m = new int* [row];
    FORi(row)
    {
        m[i] = new int[column];
    }
    return m;
}
 
///----------------------------------------------------------------------------|
/// Удаление двумерного массива.
///----------------------------------------------------------------------------:
void delete_matrix(int**& m, int row)
{
    FORi(row)
    {
        delete[] m[i];
    }
    delete[] m;
    m = NULL;
}
 
///----------------------------------------------------------------------------|
/// Вывод двумерного массива на экран.
///----------------------------------------------------------------------------:
void show_matrix(int** ptr, int ROW, int COLUMN)
{
    if (ptr == NULL) return;
    FORi(ROW)
    {
        FORj(COLUMN)
        {
            cout << ptr[i][j] << " ";
        }
        cout << std::endl;
    }
    cout << std::endl;
}
void Summation(int** ptr, int**& ptr2, int ROW, int COLUMN, int ROW2, int COLUMN2);
 
///----------------------------------------------------------------------------|
/// Старт.
///----------------------------------------------------------------------------:
int main()
{
    srand(time(NULL));
///----------------------------------------------------------------------------|
/// Задание 4
///----------------------------------------------------------------------------:
 
    int ROW, COLUMN;
    cin >> ROW >> COLUMN;
    int** ptr = create_matrix(ROW, COLUMN);
    FORi(ROW)
    {
        FORj(COLUMN)
        {
            ptr[i][j] = rand() % 5;
        }
    }
    int ROW2, COLUMN2;
    cin >> ROW2 >> COLUMN2;
    int** ptr2 = create_matrix(ROW2, COLUMN2);
    FORi(ROW2)
    {
        FORj(COLUMN2)
        {
            ptr2[i][j] = rand() % 5;
        }
    }
    cout <<
        "\n///-------------------------|" <<
        "\n/// Data matrix 1           |" <<
        "\n///-------------------------:\n";
    show_matrix(ptr, ROW, COLUMN);
    cout <<
        "\n///-------------------------|" <<
        "\n/// Data matrix 2           |" <<
        "\n///-------------------------:\n";
    show_matrix(ptr2, ROW2, COLUMN2);
 
    Summation(ptr, ptr2, ROW, COLUMN, ROW2, COLUMN2);
    delete_matrix(ptr, ROW);
    delete_matrix(ptr2, ROW2);
 
 
    cin.get();
    return 0;
}
 
///----------------------------------------------------------------------------|
/// Суммирование многомерных динамических массивов.
///----------------------------------------------------------------------------:
void Summation(int** ptr, int**& ptr2, int ROW, int COLUMN, int ROW2, int COLUMN2)
{
    int ROW3, COLUMN3;
    (ROW > ROW2) ? (ROW3 = ROW) : (ROW3 = ROW2);
    (COLUMN > COLUMN2) ? (COLUMN3 = COLUMN) : (COLUMN3 = COLUMN2);
    int** ptr3 = create_matrix(ROW3, COLUMN3);
    FORi(ROW)
        FORj(COLUMN)
        ptr3[i][j] = ptr[i][j];
    FORi(ROW2)
        FORj(COLUMN2)
        ptr3[i][j] = ptr2[i][j];
    (ROW < ROW2) ? (ROW3 = ROW) : (ROW3 = ROW2);
    (COLUMN < COLUMN2) ? (COLUMN3 = COLUMN) : (COLUMN3 = COLUMN2);
    FORi (ROW3)
    {
        FORj (COLUMN3)
        {
            ptr3[i][j] = ptr2[i][j] + ptr[i][j];
            //cout << ptr3[i][j] << " ";
        }
    }
    cout <<
        "\n///-------------------------|" <<
        "\n/// Result matrix           |" <<
        "\n///-------------------------:\n";
    (ROW > ROW2) ? (ROW3 = ROW) : (ROW3 = ROW2);
    (COLUMN > COLUMN2) ? (COLUMN3 = COLUMN) : (COLUMN3 = COLUMN2);
    show_matrix(ptr3, ROW3, COLUMN3);
    delete_matrix(ptr3, ROW3);
}

@XLAT · 20.08.2019, 13:49

Сообщение от Nuril

как выводить максимально все элементы без мусора?

может их как то по особенному инициализировать?
например:

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
///----------------------------------------------------------------------------|
///Тема: «Многомерные динамические массивы»
///Задания для самостоятельной работы #4.
///----------------------------------------------------------------------------:
#include <iostream>
#include <ctime>
#include <iomanip>
 
using namespace std;
 
#define FORi(n) for(int i = 0; i < n; ++i)
#define FORj(n) for(int j = 0; j < n; ++j)
#define LOG(n)  std::cout  << std::setw(6) << #n << " = " << n << "\n"
 
///----------------------------------------------------------------------------|
/// Двумерный динамический массив инкапсулированный в структуре.
///----------------------------------------------------------------------------:
template<class T>
class carr
{
public:
    carr(int _r, int _c) : arr(NULL), row(_r), column(_c)
    {   arr = create_arr(row, column);
    }
    
   ~carr()
    {   delete_arr(arr);
    }
    
    //------------------------------------------------------resize(int r, int c)
    void resize(int _r, int _c)
    {   row    = _r;
        column = _c;
        if(arr != NULL) 
        {   delete_arr   (arr);
            create_arr(row, column);
        }
    }
    
    //-----------------------------------------------------------init_one(T val)
    void init_one(T _val)
    {   FORi(row)
            FORj(column)
                arr[i][j] = _val;
    }
 
    int row_()
    {   return row;
    }
    int column_()
    {   return column;
    }
    
    //-----------------------------------------------------------Вывод на экран:
    void show()
    {   //std::cout << "\n";
        LOG(row);
        LOG(column);
        FORi(row)
        {   FORj(column)
            {   if(arr[i][j] != -777)
                std::cout << std::setw(5) 
                          << std::setprecision(4) 
                          << std::setfill(' ') << arr[i][j] << " \t";
                else 
                std::cout << std::setw(5) 
                          << std::setprecision(4) 
                          << std::setfill(' ') << " empty\t";
            }
            std::cout << "\n";
        }
        std::cout << "\n";
    }
 
    T* operator [](const int i)const {return arr[i];}
    
private:
    T** arr;
    int row, column;
    
    //--------------------------------------------------------------create_arr()
    T** create_arr(int r, int c)
    {   T** _arr;
        _arr = new T*[r];
        FORi(r)
        {   _arr[i] = new T[c];
        }
        return _arr;
    }
    
    //--------------------------------------------------------------delete_arr()
    void delete_arr(T**& p)
    {   FORi(row)
        {   delete[] p[i];
        }
        delete[] p;
        p = NULL;
    }
    
};
 
carr<int>* Summation(carr<int>& mat1, carr<int>& mat2);
 
///----------------------------------------------------------------------------|
/// Старт.
///----------------------------------------------------------------------------:
int main()
{   system("mode 31,50");
    srand(time(NULL));
///----------------------------------------------------------------------------|
/// Задание 4
///----------------------------------------------------------------------------:
 
    cout <<
        "\n///-------------------------|" <<
        "\n/// Data matrix 1           |" <<
        "\n///-------------------------:\n";
    int ROW = 2, COLUMN = 4;
    //cin >> ROW >> COLUMN;
    carr<int> matrix_1(ROW, COLUMN);
    FORi(ROW)
    {   FORj(COLUMN)
        {   matrix_1[i][j] = rand() % 5;
        }
    }
    matrix_1.show();
    
    cout <<
        "\n///-------------------------|" <<
        "\n/// Data matrix 2           |" <<
        "\n///-------------------------:\n";
    ROW    = 4,
    COLUMN = 2;
    //cin >> ROW >> COLUMN;
    carr<int> matrix_2(ROW, COLUMN);
    FORi(ROW)
    {   FORj(COLUMN)
        {   matrix_2[i][j] = rand() % 5;
        }
    }
    matrix_2.show();
 
    cout <<
        "\n///-------------------------|" <<
        "\n/// Result matrix           |" <<
        "\n///-------------------------:\n";
    carr<int>* m3 = Summation(matrix_1, matrix_2);
    m3->show();
 
    delete m3;
    cin.get();
    return 0;
}
 
///----------------------------------------------------------------------------|
/// Суммирование двумерных динамических массивов.
///----------------------------------------------------------------------------:
carr<int>* Summation(carr<int>& m1, carr<int>& m2)
{
    int ROW3_MAX    = std::max(m1.row_(),    m2.row_());
    int COLUMN3_MAX = std::max(m1.column_(), m2.column_());
 
    int ROW3_MIN    = std::min(m1.row_(),    m2.row_());
    int COLUMN3_MIN = std::min(m1.column_(), m2.column_());
    
    carr<int>* m3 = new  carr<int>(ROW3_MAX, COLUMN3_MAX);
               m3->init_one(-777);
 
    FORi(m1.row_())
    {   FORj(m1.column_())
        {   (*m3)[i][j] = m1[i][j];
        }
    }
    FORi(m2.row_())
    {   FORj(m2.column_())
        {   (*m3)[i][j] = m2[i][j];
        }
    }
    FORi(ROW3_MIN)
    {   FORj(COLUMN3_MIN)
        {   (*m3)[i][j] += m1[i][j];
        }
    }
    
    return m3;
}

@Yetty · 20.08.2019, 13:52

Сообщение от zss

int N=min(ROW,ROW2);
int M=min(COLUMN , COLUMN2);
for(int i=0;i<N;i++)
* for(int j=0;j<M;j++)
* * ptr3[i][j] =ptr2[i][j]+ptr[i][j];

разве можно складывать матрицы (двумерные массивы) разных размеров ? если условно наложить массивы друг на друга, Вашим способом суммируем элементы общей части - а другие части что, отбрасываются ? - мне кажется так делать нельзя и работать нужно с массивами одинаковых размеров.

@Nuril · 20.08.2019, 13:56 **[ТС]**

Сложноватый вариант

@XLAT · 20.08.2019, 15:11

Сообщение от Nuril

Сложноватый вариант

вы не правы!
наоборот так гораздо проще.

1. Все рутинные операции с динамическим двумерным массивом мы инкапсулируем в структуру(class) carr.
.....Мы избавляем себя от рутины!
2. Теперь можно сосредоточиться на решении текущей задачи.

Структуру class можно положить в отдельный файл(хедер):

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
///----------------------------------------------------------------------------|
///Тема: «Многомерные динамические массивы»
///Задания для самостоятельной работы #4.
///----------------------------------------------------------------------------:
#include <iostream>
#include <ctime>
 
using namespace std;
 
#define FORi(n) for(int i = 0; i < n; ++i)
#define FORj(n) for(int j = 0; j < n; ++j)
#define LOG(n)  std::cout  << std::setw(6) << #n << " = " << n << "\n"
 
#include "mymatrix.h" ///<<<---------------------------------------------------!
 
carr<int>* Summation(carr<int>& mat1, carr<int>& mat2);
 
///----------------------------------------------------------------------------|
/// Старт.
///----------------------------------------------------------------------------:
int main()
{   system("mode 31,50");
    srand(time(NULL));
///----------------------------------------------------------------------------|
/// Задание 4
///----------------------------------------------------------------------------:
 
    cout <<
        "\n///-------------------------|" <<
        "\n/// Data matrix 1           |" <<
        "\n///-------------------------:\n";
    int ROW = 2, COLUMN = 4;
    //cin >> ROW >> COLUMN;
    carr<int> matrix_1(ROW, COLUMN);
    FORi(ROW)
    {   FORj(COLUMN)
        {   matrix_1[i][j] = rand() % 5;
        }
    }
    matrix_1.show();
    
    cout <<
        "\n///-------------------------|" <<
        "\n/// Data matrix 2           |" <<
        "\n///-------------------------:\n";
    ROW    = 4,
    COLUMN = 2;
    //cin >> ROW >> COLUMN;
    carr<int> matrix_2(ROW, COLUMN);
    FORi(ROW)
    {   FORj(COLUMN)
        {   matrix_2[i][j] = rand() % 5;
        }
    }
    matrix_2.show();
 
    cout <<
        "\n///-------------------------|" <<
        "\n/// Result matrix           |" <<
        "\n///-------------------------:\n";
    carr<int>* m3 = Summation(matrix_1, matrix_2);
    m3->show();
 
    delete m3;
    cin.get();
    return 0;
}
 
///----------------------------------------------------------------------------|
/// Суммирование двумерных динамических массивов.
///----------------------------------------------------------------------------:
carr<int>* Summation(carr<int>& m1, carr<int>& m2)
{
    int ROW3_MAX    = std::max(m1.row_(),    m2.row_());
    int COLUMN3_MAX = std::max(m1.column_(), m2.column_());
 
    int ROW3_MIN    = std::min(m1.row_(),    m2.row_());
    int COLUMN3_MIN = std::min(m1.column_(), m2.column_());
    
    carr<int>* m3 = new  carr<int>(ROW3_MAX, COLUMN3_MAX);
               m3->init_one(-777);
 
    FORi(m1.row_())
    {   FORj(m1.column_())
        {   (*m3)[i][j] = m1[i][j];
        }
    }
    FORi(m2.row_())
    {   FORj(m2.column_())
        {   (*m3)[i][j] = m2[i][j];
        }
    }
    FORi(ROW3_MIN)
    {   FORj(COLUMN3_MIN)
        {   (*m3)[i][j] += m1[i][j];
        }
    }
    
    return m3;
}

по мне так гораздо чище, а значит проще можно концентрироваться на самой задаче.
Кроме того сей хедер можно просто(в пару кликов) подключить для решения другой задачи с динмассивами.

Добавлено через 45 минут
---

@Nuril · 20.08.2019, 22:55 **[ТС]**

Сообщение от XLAT

наоборот так гораздо проще.

Я в смысле что не вариант плохой а я ещё не проходил Классы и Векторы.

@XLAT · 21.08.2019, 00:38

Сообщение от Nuril

я ещё не проходил Классы

классы можно использовать даже не начав проходить.

1. класс есть чертеж некоторого механизма.
2. создаем объект по нужному чертежу.
3. дергаем за рычажки торчащие из интерфейса.

это всё, что нужно знать о классах, чтобы их использовать.

Новые блоги и статьи Все статьи Все блоги /
SDL3 для Web (WebAssembly): Реализация движения на Box2D v3 - трение и коллизии с повёрнутыми стенами 8Observer8 20.02.2026 Содержание блога Box2D позволяет легко создать главного героя, который не проходит сквозь стены и перемещается с заданным трением о препятствия, которые можно располагать под углом, как верхнее. . .	Конвертировать закладки radiotray-ng в m3u-плейлист damix 19.02.2026 Это можно сделать скриптом для PowerShell. Использование . \СonvertRadiotrayToM3U. ps1 <path_to_bookmarks. json> Рядом с файлом bookmarks. json появится файл bookmarks. m3u с результатом. # Check if. . .	Семь CDC на одном интерфейсе: 5 U[S]ARTов, 1 CAN и 1 SSI Eddy_Em 18.02.2026 Постепенно допиливаю свою "многоинтерфейсную плату". Выглядит вот так: https:/ / www. cyberforum. ru/ blog_attachment. php?attachmentid=11617&stc=1&d=1771445347 Основана на STM32F303RBT6. На борту пять. . .	Камера Toupcam IUA500KMA Eddy_Em 12.02.2026 Т. к. у всяких "хикроботов" слишком уж мелкий пиксель, для подсмотра в ESPriF они вообще плохо годятся: уже 14 величину можно рассмотреть еле-еле лишь на экспозициях под 3 секунды (а то и больше),. . .
И ясному Солнцу zbw 12.02.2026 И ясному Солнцу, и светлой Луне. В мире покоя нет и люди не могут жить в тишине. А жить им немного лет.	«Знание-Сила» zbw 12.02.2026 «Знание-Сила» «Время-Деньги» «Деньги -Пуля»	SDL3 для Web (WebAssembly): Подключение Box2D v3, физика и отрисовка коллайдеров 8Observer8 12.02.2026 Содержание блога Box2D - это библиотека для 2D физики для анимаций и игр. С её помощью можно определять были ли коллизии между конкретными объектами и вызывать обработчики событий столкновения. . . .	SDL3 для Web (WebAssembly): Загрузка PNG с прозрачным фоном с помощью SDL_LoadPNG (без SDL3_image) 8Observer8 11.02.2026 Содержание блога Библиотека SDL3 содержит встроенные инструменты для базовой работы с изображениями - без использования библиотеки SDL3_image. Пошагово создадим проект для загрузки изображения. . .

@Nuril 3 / 3 / 0 Регистрация: 07.11.2018 Сообщений: 119

	Поэлементно просуммировать два динамических двумерных массива 20.08.2019, 06:49. Показов 9369. Ответов 10 Метки нет (Все метки) Здравствуйте, у меня такое задание: Написать программу, которая поэлементно суммирует два динамических двумерных массива, заполненных случайными числами и сохраняет результат в третьем массиве. Размеры исходных массивов задаются пользователем. Такой вопрос я делаю программу и судя по "Размеры исходных массивов задаются пользователем" должна ли программа работать правильно при вводе размеров к примеру 4 5 и 6 2? Если да есть ли способ определить в каком из массивов есть символ? ptr3[i][j] = (ptr[i][j] < ptr2[i][j]) ? (ptr2[i][j]) : (ptr[i][j]); Мой вариант не работает. Добавлено через 7 минут Кажется я сам нашел решение своего вопроса. ptr3[i][j] = (COLUMN < COLUMN2) ? (ptr2[i][j]) : (ptr[i][j]); 0

@Nuril 3 / 3 / 0 Регистрация: 07.11.2018 Сообщений: 119
	20.08.2019, 13:56 [ТС]
	Сложноватый вариант 0

Поэлементно просуммировать два динамических двумерных массива

Решение