Форум программистов, компьютерный форум, киберфорум
С++ для начинающих
Войти
Регистрация
Восстановить пароль
 
Рейтинг 4.68/25: Рейтинг темы: голосов - 25, средняя оценка - 4.68
2 / 2 / 0
Регистрация: 07.11.2018
Сообщений: 97
1

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

20.08.2019, 06:49. Показов 4605. Ответов 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

Помощь в написании контрольных, курсовых и дипломных работ здесь.

Лучшие ответы (1)
Programming
Эксперт
94731 / 64177 / 26122
Регистрация: 12.04.2006
Сообщений: 116,782
20.08.2019, 06:49
Ответы с готовыми решениями:

Найти среднее арифметическое элементов массива, сравнить два массива поэлементно
#include &lt;iostream&gt; #include &lt;math.h&gt; #include &lt;conio.h&gt; using namespace std; void main() {...

Сложить два массива поэлементно
Необходимо базовый класс Array: массив и поле для хранения количества элементов массива......

Сложить поэлементно два массива
Помогите пожалуйста, в чем ошибка. Некорректно складывает, в итоге получается неправильный ответ...

Поэлементно сложить два массива
Всем привет, сижу делаю задание: суть такова: надо поэлементно сложить 2 массива, но при этом...

10
Модератор
Эксперт С++
11071 / 9128 / 5485
Регистрация: 18.12.2011
Сообщений: 24,399
20.08.2019, 07:06 2
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];
1
2 / 2 / 0
Регистрация: 07.11.2018
Сообщений: 97
20.08.2019, 07:15  [ТС] 3
Цитата Сообщение от 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);
}
0
Модератор
Эксперт С++
11071 / 9128 / 5485
Регистрация: 18.12.2011
Сообщений: 24,399
20.08.2019, 07:39 4
Лучший ответ Сообщение было отмечено Nuril как решение

Решение

Цитата Сообщение от 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. суммируете первую со второй в области их пересечения.
1
2 / 2 / 0
Регистрация: 07.11.2018
Сообщений: 97
20.08.2019, 12:54  [ТС] 5
Цитата Сообщение от 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);
}
0
бах-бах и в продакшен!
3034 / 1638 / 573
Регистрация: 23.09.2014
Сообщений: 5,094
Записей в блоге: 4
20.08.2019, 13:49 6
Цитата Сообщение от 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;
}
0
6500 / 4422 / 2531
Регистрация: 18.12.2017
Сообщений: 13,827
20.08.2019, 13:52 7
Цитата Сообщение от 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];
разве можно складывать матрицы (двумерные массивы) разных размеров ? если условно наложить массивы друг на друга, Вашим способом суммируем элементы общей части - а другие части что, отбрасываются ? - мне кажется так делать нельзя и работать нужно с массивами одинаковых размеров.
0
2 / 2 / 0
Регистрация: 07.11.2018
Сообщений: 97
20.08.2019, 13:56  [ТС] 8
Сложноватый вариант
0
бах-бах и в продакшен!
3034 / 1638 / 573
Регистрация: 23.09.2014
Сообщений: 5,094
Записей в блоге: 4
20.08.2019, 15:11 9
Цитата Сообщение от 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 минут
---
0
2 / 2 / 0
Регистрация: 07.11.2018
Сообщений: 97
20.08.2019, 22:55  [ТС] 10
Цитата Сообщение от XLAT Посмотреть сообщение
наоборот так гораздо проще.
Я в смысле что не вариант плохой а я ещё не проходил Классы и Векторы.
0
бах-бах и в продакшен!
3034 / 1638 / 573
Регистрация: 23.09.2014
Сообщений: 5,094
Записей в блоге: 4
21.08.2019, 00:38 11
Цитата Сообщение от Nuril Посмотреть сообщение
я ещё не проходил Классы
классы можно использовать даже не начав проходить.

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

это всё, что нужно знать о классах, чтобы их использовать.
0
IT_Exp
Эксперт
87844 / 49110 / 22898
Регистрация: 17.06.2006
Сообщений: 92,604
21.08.2019, 00:38

Поэлементно суммировать два заданных массива
Подскажите пожалуйста как решить задачу: Дано два массива 1-10, нужно чтобы первый цифр первого...

Сложить поэлементно два массива I и J. Результат в массиве I
Помогите пожалуйста написать программу: Сложить поэлементно два массива I(10) и J(10). Результат в...

Сложить два двумерных массива
Как сложить два двумерных массива???Вот ф-ии для ввода двух массивов и геттеры для них. Надо ф-ию...

Сравнить поэлементно два одномерных массива, и через if определить, равны эти элементы или нет
Люди помогите пожалуйста Нужно сравнить по элементам два одномерных массива и через if определить...


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

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

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