1

我需要在 C++ 中设置和访问结构的二维向量。我的结构定义为：

struct nodo{
  int last_prod;
  int last_slot;
  float Z_L;
  float Z_U;
  float g;
  bool fathomed;
};

我将向量定义为：

vector<vector<struct nodo> > n_2;

现在，我需要创建 n_2 的几个元素，然后它们将再次成为向量，然后访问它们的单个成员。我怎样才能做到这一点？这是我到目前为止的一段代码：

for(int i=1;i<112;i++){
    n_2.push_back(vector<struct nodo>(111-i));       
    for(int j=1;j<112-i;j++){
      n_2[i][j].last_prod=j;
    }
}

这是行不通的。

4

7 回答 7

3

一个向量的大小为 0，直到您告诉它调整大小，或者除非您使用特定大小对其进行初始化。创建向量时传入向量的大小：

for(int i=1;i<112;i++){
    n_2.push_back(vector<struct nodo>(112-i));       
    for(int j=1;j<112-i;j++){
      n_2[i][j].last_prod=j;
    }
}

此外，您似乎正在跳过第 0 个索引，这意味着您的数组中的第一个值将被跳过。这可能是不希望的。

最后，如果您的数组是一个固定大小，请考虑使用std::array而不是 std::vector。请注意，std::array 是 C++11 功能，可能不可用，具体取决于您的编译器。

如果我正在编写这段代码，我可能会这样写：

#include <array>
using namespace std;

// allocate an array of 112 <struct nodo> arrays, each of size 112
array<array<struct nodo, 112>, 112> n_2;
for (int i = 0; i < 112; i++)
{
    for (int j = 0; j < 112; j++)
    {
        n_2[i][j].last_prod = j;
    }
}

或者，如果我没有支持 C++11 的编译器：

#include <vector>
using namespace std;

// allocate a vector of size 112 of <struct nodo> vectors, each of size 112
vector<vector<struct nodo> > n_2(112, vector<struct nodo>(112));
for (int i = 0; i < 112; i++)
{
    for (int j = 0; j < 112; j++)
    {
        n_2[i][j].last_prod = j;
    }
}

更理想的是，您应该使用 1 维向量，并将其简单地视为 2 维向量。这样，您可以一次进行一次内存分配，而不是 112 次较小的分配。这变得非常挑剔，但显然 O(1) 解决方案优于 O(n) 解决方案，而 O(n) 解决方案在分配方面优于 O(n^2) 解决方案，因为分配速度很慢。

于 2012-02-20T16:58:08.317 回答
0

在外循环中，您正在创建一个空向量（更新：问题更改后，它不再是空的，但仍然不够大）；您需要以足够大的尺寸创建它：

n_2.push_back(vector<struct nodo>(112-i));
于 2012-02-20T17:00:49.520 回答
0

首先，这不是一个很好的方法。如果您事先知道尺寸，我实际上建议您在这一点上使用普通的二维数组。或者，为了保持“C++”，您可以将向量包装在某些东西中并提供更易懂的界面。

其次，如果您打算在没有迭代器的情况下直接访问向量，则应该从 0 开始您的数组索引。

但是，如果你真的想这样做，你的问题是你需要在引用它的元素之前填充向量。

所以，

n_2.push_back(vector<struct nodo>());
n_2[0].push_back(nodo());

//You can now access n_2[0][0] as there is a single nodo element in there.

在访问该元素所在的位置之前，您需要确保已将元素添加到嵌套向量中。因此，您的代码可能是：

for(int i=0;i<112;i++){
    n_2.push_back(vector<struct nodo>());       
    for(int j=0;j<112-i;j++){
      //At n_2[i] which we made above, add another nodo.
      n_2[i].push_back(nodo());
    }
}
于 2012-02-20T17:01:04.850 回答
0

我建议您使用调整大小，至少对我来说它看起来更整洁：

n_2.resize(112);
for(int i = 1; i < 112; i++){
    n_2[i].resize(112- i);  
    for(int j = 1; j < 112 - i; j++){
      n_2[i][j].last_prod = j;
    }
}
于 2012-02-20T17:03:01.033 回答
0

您必须注意的第一件事是（在两个周期中）必须从 0 而不是 1 开始的起始索引。

另一件事是您必须在嵌套向量内推一些东西才能解决它（使用运算符 []）。

于 2012-02-20T17:05:34.640 回答
0 
for(int i=1;i<112;i++){
    n_2.push_back(vector<struct nodo>(111-i)); 
    // Here you only have n_2[0] ... n_2[i-1] ( the last pushed is n_2[i-1] )
    // So n_2[i] will be out of range
    // And for n_2[i-1], you only have n_2[i-1][0] ... n_2[i-1][110-i]
    // So be careful of the j's value    
    for(int j=1;j<112-i;j++){
      n_2[i][j].last_prod=j;
    }
}
于 2012-02-20T17:07:32.813 回答
0

您正在尝试访问尚不存在的项目。 

for(int i=1;i<112;i++){
    n_2.push_back(vector<struct nodo>()); <--allocates an empty vector    
    for(int j=1;j<112-i;j++){
      n_2[i][j].last_prod=j; <-- accesses indexes in the empty vector
    }
}

要么提前分配向量中的项目，要么根据需要创建。更好的选择是使用数组而不是向量，因为无论如何您都不会调整向量的大小。这将有性能提升。

于 2012-02-20T17:08:59.940 回答