Я строю матричный класс шаблона для использования в моем будущем коде c ++.У меня есть несколько вопросов, касающихся передачи значений для перегруженных операторов, исключений и утверждений и общего дизайна класса.
Правильно ли я передаю значения?Это эффективно?Что я могу сделать иначе, чтобы сделать это лучше?
Эта библиотека построена с учетом будущего дизайна приложения (терминал или графический интерфейс), где пользователь может определять свои собственные матрицы и выполнять вычисления.Было бы лучше использовать исключения вместо утверждений в этом случае?
Я искал правило 5 для c ++, где говорится, что:
Потому чтоналичие пользовательского деструктора , конструктор копирования или оператор копирования-назначения предотвращает неявное определение конструктора перемещения и оператора назначения перемещения, любогокласс, для которого желательна семантика перемещения, должен объявить все пять специальных функций-членов.
Могу ли я обойтись без реализации этого правила, просто не имея ни одного из этих трех? ** Что было быСтандартный способ сделать этот класс более функциональным?
В моей программе определены вычитание, умножение и деление (скалярные) с такой же / сходной структурой, как и у предоставленных определений операторов сложения, поэтомуздесь не весь этот код необходим.
Принимается любой жесткий совет или критика в отношении общего дизайна!
#ifndef MACMATRICES_H
#define MACMATRICES_H
#include <vector>
#include <iomanip>
#include <iostream>
#include <exception>
#include "../../DMF-Terminal.h"
namespace DMF
{
template <typename T>
class matrix
{
public:
// Constructors
matrix();
matrix(int p_rows, int p_columns);
// Operators
std::vector<T>& operator[] (size_t i) { return m[i]; }
matrix<T> operator+(const matrix<T>& rhs);
matrix<T> operator+(const T& rhs);
matrix<T>& operator+=(const matrix<T>& rhs);
matrix<T>& operator+=(const T& rhs);
// Class Methods
void print() const;
matrix<T> inverse();
T determinant();
// Observers
bool isSquare() const;
int rowSize() const { return m_rows; }
int colSize() const { return m_cols; }
private:
int m_rows, m_cols;
std::vector< std::vector<T> > m;
};
/ * Конструкторs ----------------------------------------------------------------------------------- * /
template <typename T>
matrix<T>::matrix(){}
template <typename T>
matrix<T>::matrix(int p_rows, int p_cols) :
m(p_rows, std::vector<T>(p_cols)), m_rows(p_rows), m_cols(p_cols) {}
/ * Дополнение -------------------------------------------------------------------------------------- * /
template <typename T>
matrix<T> matrix<T>::operator+(const matrix<T>& rhs)
{
try
{
if((this->rowSize() == rhs.rowSize()) && (this->colSize() == rhs.colSize()))
{
matrix<T> sum (this->rowSize(), this->colSize());
for(int i = 0; i < this->rowSize() ; ++i)
{
for(int j = 0; j < this->colSize(); ++j)
sum.m[i][j] = this->m[i][j] + rhs.m[i][j];
}
return sum;
}
else throw std::runtime_error("Cannot add matrices, invalid row/column sizes.");
}
catch (std::exception &e)
{
std::cout << "Error: " << e.what(); DMF::wait();
}
}
template <typename T>
matrix<T> matrix<T>::operator+(const T& rhs)
{
matrix<T> sum (this->rowSize(), this->colSize());
for(int i = 0; i < this->rowSize() ; ++i)
{
for(int j = 0; j < this->colSize(); ++j)
sum.m[i][j] = this->m[i][j] + rhs;
}
return sum;
}
template <typename T>
matrix<T>& matrix<T>::operator+=(const matrix<T>& rhs)
{
try
{
if((this->rowSize() == rhs.rowSize()) && (this->colSize() == rhs.colSize()))
{
for(int i = 0; i < this->rowSize() ; ++i)
{
for(int j = 0; j < this->colSize(); ++j)
this->m[i][j] += rhs.m[i][j];
}
return *this;
}
else throw std::runtime_error("Cannot add matrices, invalid row/column sizes.");
}
catch (std::exception &e)
{
std::cout << "Error: " << e.what(); DMF::wait();
}
}
template <typename T>
matrix<T>& matrix<T>::operator+=(const T& rhs)
{
matrix<T> sum (this->rowSize(), this->colSize());
for(int i = 0; i < this->rowSize() ; ++i)
{
for(int j = 0; j < this->colSize(); ++j)
this->m[i][j] += rhs;
}
return *this;
}
}
#endif /* MACMATRICES_H */
По состоянию на сейчасэтот код работает в программе мини терминала.У меня также есть матрица * матрица и матрица * = матричные операторы перегружены, и кажется, что они работают правильно, в результате размер матрицы результата будет правильным.