Как реализовать матричный класс с динамически размещенными элементами?

Question

Как реализовать матричный класс с динамически размещенными элементами?

У меня есть домашнее задание с просьбой implement a matrix class with that uses dynamic allocation to store its elements, Класс должен позволять сложение и вычитание.
Ему нужно освободить память, которая больше не нужна для хранения элементов.

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

-1

c++class conceptual dynamic-memory-allocation

Решение

Другие решения

Вам не нужен «класс элемента». Вам не нужен «адрес следующего элемента». ИМО, ты делаешь это излишне сложным.

Матрица — это двумерный массив.
Самый простой способ представить 2D-массив с numRows строки и numColumns столбцы, чтобы сделать 1D массив с размером numRows * numColumns,
В таком массиве смещение отдельного элемента (rowIndex, columnIndex) можно рассчитать как rowIndex * numCOlumns + columnIndexгде оба индекса начинаются с нуля. И вы знаете, как разместить 1D массив, верно?

0

Class Matrix:
{
private:
int**m;
public:
Matrix();//allocate memory
Realocate_memory(int**, int rows, int cols); //in case you want to modify the size of the matrix - this will be the most complicated part as you need to handle memory allocation.
Free(int**m, int rows, int cols);

// other methods....
}

сложная часть здесь — удаление неиспользуемых элементов — поскольку вам необходимо сохранить структуру матрицы, есть несколько ограничений:
— вы можете удалить только целые строки / столбцы
— вы можете перемещать данные, если это разрешено, чтобы в итоге вы получили полные строки / столбцы неиспользуемых элементов — но лично я не стал бы беспокоиться о таком подходе

Вы также можете выделить больше памяти, когда у вас заканчивается свободное место — здесь вы можете использовать подход с динамическим массивом:
— выделить новую матрицу размером 2х
— скопировать старый в новый
— освободи старого.

надеюсь это поможет!

0

Источник

Accepted Answer

Возможно, если вы скажете, что имеете в виду, люди не ответят на то, что вы написали.

Ваша матрица должна динамически выделяться для хранения ее членов.

Лучший способ сделать это — не быть двумерным, а быть одномерным в своем распределении. Вам нужно M * N элементов, поэтому выделите M * N за один раз.

Чтобы найти элемент (i, j), на самом деле это элемент (i * M) + j.

Таким образом, у вас есть что-то вроде, если элементы двойные

class Matrix
{
private:
double * m_mem;
size_t m_width;
size_t m_height;
public:
Matrix( size_t width, size_t height );
~Matrix();

double operator()( size_t i, size_t j ) const
{
return m_mem[ i * m_width + j ];
}
double& operator()( size_t i, size_t j )
{
return m_mem[ i * m_width + j ];
}

size_t width() const
{
return m_width;
}

size_t height() const
{
return m_height;
}

Matrix(Matrix const& other ); // you implement
Matrix& operator=( Matrix const& other ); // you implement
};

Вам понадобятся 2 перегрузки для operator (), неконстантные для установки этих членов.
Вы можете проверить границы.

Выделите так:

     Matrix::Matrix( size_t width, size_t height ) :
m_mem( new double[width * height] ),
m_width( width ),
m_height( height )
{
}

Бесплатно таким образом:

     Matrix::~Matrix()
{
delete [] m_mem;
}

Вам нужно будет управлять копированием и назначением, учитывая правило 3.

Невозможно освободить часть вашей матрицы.

Если вы хотите сделать Matrix универсальным, вы должны написать шаблон. Но я не знаю, научились ли вы писать шаблоны.

Для сложения и вычитания вы можете использовать членов класса или:

     Matrix operator+( Matrix const& left, Matrix const& right )
{
assert( left.width == right.width );
assert( left.height == right.height );
Matrix sum( left.width, left.height );
for( size_t i = 0; i < left.width; ++i )
{
for( size_t j = 0; j < left.height; ++j )
{
sum( i, j ) = left( i, j ) + right( i, j );
}
}
return sum; // in C++11 return std::move(sum) and return-type Matrix&&
}

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

0