指针指向向量的指针产生3D向量?

Question

我一直在查看一些遗留代码，发现了这个小片段:

std::vector<int>** grid = new std::vector<int>*[10];
for (int k = 0; k < 10; k++) 
grid[k] = new std::vector<int>[10];

然后，最初的开发人员在这里调用这个命令:

grid [i][j].push_back(temp);

我的印象是[i][j]将返回嵌套向量中的值，但是通过使用push_back意味着在该位置有一个指向向量的指针?我不明白第三个向量是从哪里来的

还有，有没有更好的方法?三重嵌套向量也会达到与上述代码相同的结果吗?

提前感谢!

Answer 1

grid[i][j]是对std::vector<int>的引用。

重写东西可以让你更清楚地知道你有什么。

(演示)

#include <fmt/ranges.h>
#include <vector>
int main() {
using line_t = std::vector<int>;  // line is a vector of ints
using matrix_t = line_t*;  // matrix is an array of lines
using grid_t = matrix_t*;  // grid is an array of matrices
// Same as: grid_t grid{ new std::vector<int>*[3] };
grid_t grid{ new matrix_t[3] };
int v{};
for (int k = 0; k < 3; k++) {  // we walk each matrix
auto& matrix{ grid[k] };
matrix = new line_t[3];
for (int l = 0; l < 3; l++, v++) {  // we walk each line
// Same as: auto& line{ grid[k][l] };
auto& line{ matrix[l] };
line = std::vector<int>(3, v);
}
}
fmt::print("Gridnn");
for (int k{0}; k < 3; k++) {
fmt::print("Matrix {}n", k);
auto& matrix{ grid[k] };
for (int l{0}; l < 3; l++) {
auto& line{ matrix[l] };
fmt::print("{}n", line);
}
fmt::print("n");
}
}

// Outputs:
//
//   Grid
//
//   Matrix 0
//   [0, 0, 0]
//   [1, 1, 1]
//   [2, 2, 2]
//
//   Matrix 1
//   [3, 3, 3]
//   [4, 4, 4]
//   [5, 5, 5]
//
//   Matrix 2
//   [6, 6, 6]
//   [7, 7, 7]
//   [8, 8, 8]

---

使用std::vectors代替内置数组将大大简化事情。

(演示)

#include <algorithm>  // fill
#include <fmt/ranges.h>
#include <vector>
int main() {
using line_t = std::vector<int>;  // line is a vector of ints
using matrix_t = std::vector<line_t>;  // matrix is a vector of lines
using grid_t = std::vector<matrix_t>;  // grid is a vector of matrices
grid_t grid(3, matrix_t(3, line_t(3)));
int v{};
for (auto& matrix : grid) {
for (auto& line : matrix) {
std::ranges::fill(line, v++);
}
}
fmt::print("Gridnn");
for (int k{0}; k < 3; k++) {
fmt::print("Matrix {}n", k);
fmt::print("{}nn", fmt::join(grid[k], "n"));
}
}

Answer 2

这是一个不懂c++的人写的一堆乱七八糟的东西。

grid[i][j]是对std::vector<int>的引用(不是指针)。

还有，有没有更好的方法?三重嵌套向量也会达到与上述代码相同的结果吗?

是的，std::vector<std::vector<std::vector<int>>> grid { 10, { 10, {} } };将是。

然而，如果你想确保每个元素中有相同数量的元素，你应该使用矩阵类。

somelib::matrix<std::vector<int>> grid(10, 10); // probably only does one allocation of 100 vectors

Answer 3

我想你的困惑是有两个维度由指针组成，一个维度由向量组成。

总共有100个带有整数的向量。

grid[]    -> contains 10 pointers which each point to an array of vector pointers
grid[][]  -> contains 10 pointers to vectors
*grid[][] -> a vector of integers