F
Sewing schrieb:
Finnegan, was wäre denn deine Idee um hier die Effizienz zu steigern?
Siehe Jockelx' Antwort.
Zusätzlich ist es nicht verkehrt die Speicherverwaltung einem Container der
Standardbibliothek zu überlassen ( std::vector ). Für eine dynamische Matrix
(Dimensionen erst zur Laufzeit bekannt, da User-Eingabe) wird sich der daraus
erzeugte Maschinencode wahrscheinlich nicht von der "manuellen" Variante unterscheiden.
Ein Ansatz dafür könnte z.B. so aussehen:
#include <iostream>
#include <vector>
template <typename T>
class matrix
{
public:
matrix(std::size_t m, std::size_t n)
: rows(m), cols(n), elements(m * n)
{
assert(m * n > 0);
}
std::size_t getRows() const
{
return rows;
}
std::size_t getCols() const
{
return cols;
}
T& operator()(std::size_t i, std::size_t j)
{
assert(i < rows && j < cols);
return elements[i * cols + j];
}
const T& operator()(std::size_t i, std::size_t j) const
{
assert(i < rows && j < cols);
return elements[i * cols + j];
}
private:
std::size_t rows;
std::size_t cols;
std::vector<T> elements;
};
template <typename T>
std::ostream& operator<<(std::ostream& out, const matrix<T>& m)
{
out << "{ ";
for (std::size_t i = 0; i < m.getRows(); ++i)
{
out << ((i > 0) ? ", [" : "[");
for (std::size_t j = 0; j < m.getCols(); ++j)
out << ((j > 0) ? ", " : " ") << m(i, j);
out << " ]";
}
out << " }";
return out;
}
int main()
{
matrix<double> m{ 3, 3 };
std::cout << m << std::endl;
m(0, 0) = 1;
m(1, 1) = 1;
m(2, 2) = 1;
std::cout << m(0, 0) << std::endl;
std::cout << m << std::endl;
return 0;
}
Das ist zumindest die Art und Weise wie ich heutzutage eine solche Matrix implementieren würde.
