迭代器运算符++重载C++
迭代器运算符++重载C++
提问于 2020-03-02 18:20:34
我正在使用二维std::vector编写自定义类Matrix。所以问题是我需要重载迭代器的++操作，这样我就可以一次遍历整个矩阵。
template <typename T>
class Matrix {
private:
std::vector<std::vector<T>> arr;
public:
Matrix(const std::vector<std::vector<T>>& tmp) {
arr = tmp;
}
std::pair<size_t, size_t> size() const {
std::pair<size_t, size_t> tmp;
if (arr.empty()) {
tmp.first = 0;
tmp.second = 0;
} else {
tmp.first = arr.size();
tmp.second = arr[0].size();
}
return tmp;
}
T operator () (size_t i, size_t j) const {
return arr[i][j];
}
Matrix& transpose() {
std::vector<std::vector<T>> tmp(size().second, std::vector<T>(size().first));
for (size_t i = 0; i < size().first; ++i) {
for (size_t j = 0; j < size().second; ++j) {
tmp[j][i] = arr[i][j];
}
}
*this = Matrix(tmp);
return *this;
}
Matrix transposed() const {
std::vector<std::vector<T>> tmp(size().second, std::vector<T>(size().first));
for (size_t i = 0; i < size().first; ++i) {
for (size_t j = 0; j < size().second; ++j) {
tmp[j][i] = arr[i][j];
}
}
return Matrix(tmp);
}
typename std::vector<T>::iterator begin() {
return arr[0].begin();
}
typename std::vector<T>::iterator end() {
return arr[size().first-1].end();
}
};例如，矩阵mat = {{1,2}，{3,4}}，这应该是可行的：
vector<vector<int>> arr = {{1,2},{3,4}};
Matrix mar(arr);
auto it = mat.begin();
while (it != mat.end()) {
cout << *it << " ";
}输出应该是：
1 2 3 4 你能告诉我如何为std::vector迭代器重载operator++()，begin()和end()吗？
回答 3
Stack Overflow用户
发布于 2020-03-02 18:28:20
您不能只使用std::vector返回的迭代器并更改它的任何方法。如果您愿意，可以创建自己的迭代器类(例如，一个将两个迭代器包含到内部向量中的类)，该类将返回矩阵类，并为它们实现相关方法。
Stack Overflow用户
发布于 2020-03-02 18:45:45
向量我正在使用二维std：：
编写自定义类Matrix。
别干那事。为什么？
- 你在重新发明轮子。您的用例不太可能如此特殊，以至于现有的矩阵/线性代数库都不能满足您的需求。
- 没有二维向量；您的意思是向量的向量(这就是您的示例所具有的)。这通常会有点慢，而且-它的语义可能不是您想要的(例如，调整单个行的大小的能力，分散在整个堆中的行存储等等)
您可能想要考虑一下，举一个我想不到的例子，the Eigen library's matrix class。
Stack Overflow用户
发布于 2020-03-03 05:44:21
因此，使用一维(听起来不正确)向量的决策是有效的。谢谢大家！
#include <iostream>
#include <utility>
#include <vector>
template <typename T>
class Matrix {
private:
std::vector<T> arr;
size_t m = 0;
size_t n = 0;
public:
Matrix(const std::vector<std::vector<T>>& tmp) {
for (const auto& row : tmp) {
for (const auto& x : row) {
arr.push_back(x);
}
}
if (!tmp.empty()) {
m = tmp.size();
n = tmp[0].size();
}
}
std::pair<size_t, size_t> size() const {
std::pair<size_t, size_t> tmp;
tmp.first = m;
tmp.second = n;
return tmp;
}
T operator () (size_t i, size_t j) const {
return arr[i * m + j];
}
Matrix transposed() const {
std::vector<std::vector<T>> tmp(size().second, std::vector<T>(size().first));
for (size_t i = 0; i < size().first; ++i) {
for (size_t j = 0; j < size().second; ++j) {
tmp[j][i] = arr[i * m + j];
}
}
return Matrix(tmp);
}
Matrix& transpose() {
*this = transposed();
return *this;
}
auto begin() {
return arr.begin();
}
auto end() {
return arr.end();
}
auto begin() const {
return arr.begin();
}
auto end() const {
return arr.end();
}
};
template <typename T>
std::ostream& operator<<(std::ostream& out, const Matrix<T>& m) {
for (size_t i = 0; i < m.size().first; ++i) {
for (size_t j = 0; j < m.size().second; ++j) {
if (j == 0)
out << m(i, j);
else
out << "\t" << m(i, j);
}
if (i != m.size().first - 1)
out << "\n";
}
return out;
}
template <typename T>
Matrix<T> operator + (const Matrix<T>& m1, const Matrix<T>& m2) {
std::vector<std::vector<T>> tmp(m1.size().first, std::vector<T>(m1.size().second));
for (size_t i = 0; i < m1.size().first; ++i) {
for (size_t j = 0; j < m1.size().second; ++j) {
tmp[i][j] = m1(i, j) + m2(i, j);
}
}
return Matrix(tmp);
}
template <typename T>
Matrix<T>& operator += (Matrix<T>& m1, const Matrix<T>& m2) {
m1 = m1 + m2;
return m1;
}
template <typename T1, typename T2>
Matrix<T1> operator * (const Matrix<T1>& m, const T2& x) {
std::vector<std::vector<T1>> tmp(m.size().first, std::vector<T1>(m.size().second));
for (size_t i = 0; i < m.size().first; ++i) {
for (size_t j = 0; j < m.size().second; ++j) {
tmp[i][j] = m(i, j) * x;
}
}
return Matrix(tmp);
}
template <typename T1, typename T2>
Matrix<T1> operator * (const T2& x, const Matrix<T1>& m) {
return m * x;
}
template <typename T1, typename T2>
Matrix<T1>& operator *= (Matrix<T1>& m, const T2& x) {
m = m * x;
return m;
}
template <typename T>
Matrix<T> operator * (const Matrix<T>& first, const Matrix<T>& second) {
std::vector<std::vector<T>> tmp(first.size().first, std::vector<T>(second.size().second));
T x = 0;
for (size_t i = 0; i < first.size().first; ++i) {
for (size_t j = 0; j < second.size().second; ++j) {
for (size_t k = 0; k < first.size().second; ++k) {
x += first(i, k) * second(k, j);
}
tmp[i][j] = x;
x = 0;
}
}
return Matrix(tmp);
}
template <typename T>
Matrix<T>& operator *= (Matrix<T>& first, const Matrix<T>& second) {
first = first * second;
return first;
}页面原文内容由Stack Overflow提供。腾讯云小微IT领域专用引擎提供翻译支持
原文链接：
https://stackoverflow.com/questions/60486759
复制相关文章
相似问题
腾讯云开发者
