Матрица — это таблица чисел

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

Выбор шаблонных параметров

Наш класс должен поддерживать работу с разными типами элементов. Поэтому вынесем тип элемента в шаблонные параметры:

template <typename T>

class Matrix;

Теперь решим, будут ли размеры матрицы известны во время компиляции. Если да, их можно сделать шаблонными параметрами, а хранить матрицу можно в двумерном контейнере std::array:

#include <array>

template <typename T, size_t Rows, size_t Columns>

class Matrix {

private:

std::array<std::array<T, Columns>, Rows> data;

};

Пример использования:

int main() {

Matrix<int, 3, 4> m; // матрица размера 3 x 4

}

Однако чаще размеры матрицы становятся известными только во время выполнения программы. Тогда шаблонные размеры не подойдут, так как аргументы шаблона должны быть известны в момент компиляции. В этом случае размеры должны содержаться в данных самой матрицы, а не в её типе. Хранить матрицу будем в двумерном векторе:

#include <vector>

template <typename T>

class Matrix {

private:

std::vector<std::vector<T>> data;

public:

size_t GetRows() const {

return data.size();

}

size_t GetColumns() const {

if (data.empty()) {

return 0;

}

return data[0].size();

}

};

Конструкторы

Конструктор из вектора векторов

Напишем конструктор, который принимает двумерный вектор и соблюдает инвариант «в строках матрицы одинаковое количество элементов»:

template <typename T>

class Matrix {

private:

std::vector<std::vector<T>> data;

void MakeRectangle() {

size_t maxSize = 0;

for (const auto& row : data) {

if (row.size() > maxSize) {

maxSize = row.size();

}

}

for (auto& row : data) {

row.resize(maxSize);

}

}

public:

Matrix(const std::vector<std::vector<T>>& d) : data(d) {

MakeRectangle();

}

};

Пример использования:

int main() {

Matrix<int> m({

{1, 2, 3},

{4, 5, 6},

});

std::cout << m.GetRows() << "\n"; // 2

std::cout << m.GetColumns() << "\n"; // 3

}

Конструктор для нулевой матрицы

Добавим конструктор для создания нулевой матрицы заданных размеров:

template <typename T>

class Matrix {

private:

std::vector<std::vector<T>> data;

public:

Matrix(size_t rows, size_t columns) {

data.resize(rows);

for (auto& row : data) {

row.resize(columns);

}

}

};

Пример использования:

int main() {

Matrix<int> m(3, 4); // создаём нулевую матрицу из 3 строк и 4 столбцов

}

Обращение к элементам и перегрузка по константности

Хочется обращаться к элементам матрицы так же, как и с двумерным массивом:

int main() {

Matrix<int> m(3, 4);

int element = m[0][0];

m[1][1] = 1;

m[2][3] = 5;

}

Для этого перегрузим оператор []. Однако нужно учесть два случая: чтение и запись. Для этого перегрузим оператор по константности:

template <typename T>

class Matrix {

private:

std::vector<std::vector<T>> data;

public:

const std::vector<T>& operator[](size_t i) const {

return data[i];

}

std::vector<T>& operator[](size_t i) {

return data[i];

}

};

Теперь первая версия будет применяться к константным матрицам, а вторая — к неконстантным.

Итерация по матрице

Чтобы можно было писать цикл range-based for по строкам матрицы, добавим функции begin и end:

template <typename T>

class Matrix {

private:

std::vector<std::vector<T>> data;

public:

using const_iterator = typename std::vector<std::vector<T>>::const_iterator;

const_iterator begin() const {

return data.cbegin();

}

const_iterator end() const {

return data.cend();

}

};

Пример использования:

int main() {

Matrix<int> m(3, 4);

for (const auto& row : m) {

// обрабатываем строку row

}

}

Потоковый ввод и вывод

Перегрузим операторы << и >> для удобства работы с потоками:

template <typename T>

std::ostream& operator<<(std::ostream& out, const Matrix<T>& matrix) {

const size_t rows = matrix.GetRows();

const size_t columns = matrix.GetColumns();

for (size_t i = 0; i != rows; ++i) {

for (size_t j = 0; j != columns; ++j) {

if (j > 0) {

out << "\t";

}

out << matrix(i, j);

}

out << "\n";

}

return out;

}

template <typename T>

std::istream& operator>>(std::istream& in, Matrix<T>& matrix) {

const size_t rows = matrix.GetRows();

const size_t columns = matrix.GetColumns();

for (size_t i = 0; i != rows; ++i) {

for (size_t j = 0; j != columns; ++j) {

in >> matrix(i, j);

}

}

return in;

}

Пример использования:

int main() {

Matrix<int> m(3, 4);

std::cin >> m;

std::cout << m;

}

Арифметические операции

Оператор +=

Реализуем оператор += для сложения матриц одинакового размера:

template <typename T>

Matrix<T>& operator+=(const Matrix<T>& other) {

const size_t rows = GetRows();

const size_t columns = GetColumns();

if (rows != other.GetRows() || columns != other.GetColumns()) {

throw std::invalid_argument("Matrices have different size!");

}

for (size_t i = 0; i != rows; ++i) {

for (size_t j = 0; j != columns; ++j) {

data[i][j] += other.data[i][j];

}

}

return *this;

}

Оператор +

Реализуем оператор +, используя уже написанный оператор +=:

template <typename T>

Matrix<T> operator+(const Matrix<T>& m1, const Matrix<T>& m2) {

auto tmp = m1;

tmp += m2;

return tmp;

}

Сравнение матриц

Напишем операторы == и != для сравнения двух матриц:

template <typename T>

bool operator==(const Matrix<T>& other) const {

const size_t rows = GetRows();

const size_t columns = GetColumns();

if (rows != other.GetRows() || columns != other.GetColumns()) {

return false;

}

for (size_t i = 0; i != rows; ++i) {

for (size_t j = 0; j != columns; ++j) {

if (!((*this)(i, j) == other(i, j))) {

return false;

}

}

}

return true;

}

template <typename T>

bool operator!=(const Matrix<T>& m1, const Matrix<T>& m2) {

return !(m1 == m2);

}

Таким образом, шаблонные классы позволяют создавать универсальные и гибкие структуры данных, которые легко адаптировать под разные задачи.