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

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

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

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

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

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

C++

///----------------------------------------------------------------------------|
/// Вывод двумерного массива 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++

///----------------------------------------------------------------------------|
///Тема: «Многомерные динамические массивы»
///Задания для самостоятельной работы #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);
}

Вернуться к обсуждению:
Поэлементно просуммировать два динамических двумерных массива C++

Следующий ответ