c++中初始化结构体向量的正确方法

c++ right way to initialize a vector of a struct

本文关键字：方法 向量 初始化 结构体 c++      更新时间：2023-10-16

我在这里搜索了很多，但是对于我来说没有正确的解释，对于一个高级的c++新手。我以前用结构向量工作过，现在我得到分割错误…

这就是为什么我想知道这些对象实际上是如何工作的，如果它是正确的我正在做的方式!

我有一个像 这样的结构体
struct numberOfSpecies {
   int predator;
   int prey1;
   int prey2;
};

及其向量:

std::vector<numberOfSpecies> size;

在我调整它的大小并填充它的值之前。

size.resize(100);

这实际上在做什么?这对结构体合适吗?看起来它是用零初始化的…

现在我这样做:

size[t].predator=0;
size[t].prey1=0;
size[t].prey2=0;
for(int k = 0; k < N; ++k){
  size[t].predator++;
  size[t].prey1++;
  size[t].prey2++;
}

这样对吗?可能的问题在哪里?如何做得更好?

这里最简单和"正确"的解决方案可能只是使用resize()函数，该函数属于具有聚合初始化的矢量对象(如果您可以访问c++11及以上版本)，如

size.resize(100,{0,0,0}); //aggregate initialization 
for(int k = 0; k < N; ++k)
{
    size[t].predator++;
    size[t].prey1++;
    size[t].prey2++;
}

每个numberOfSpecies对象的所有成员将初始化为0

This:

size[t].predator=0;
size[t].prey1=0;
size[t].prey2=0;

将对size的元素t写入零-这可能有用，也可能没用:

: 

for(int k = 0; k < N; ++k){
  size[t].predator++;
  size[t].prey1++;
  size[t].prey2++;
}

将size的t元素增加N次。这似乎不太可能有用。我认为你需要的是:

size[0].predator=0;  // Technically not needed because .resize()
size[0].prey1=0;     // will have initialized it to zero anyway
size[0].prey2=0;     // *BUT* explicit is always better than implicit.
// Initialize each element of size to be one greater than previous.
for(int k = 1; k < N; ++k){
  size[k].predator = size[k-1].predator + 1;
  size[k].prey1    = size[k-1].prey1    + 1;
  size[k].prey2    = size[k-1].prey2    + 1;;
}

使用value参数作为静态参数

#include <vector>
struct foo{
    int g;
    int h;
    int l;
};
int main()
{
    std::vector<foo> manyFoo(10, {0});
    manyFoo.resize(60, {0});
}

如果你想增加你的向量，你也可以在结构体中添加任意值，你可以->

#include <iostream>
#include <vector>
struct foo{
    foo(int aG,int aH, int aL):g(aG),h(aH),l(aL) {};
    int g;
    int h;
    int l;
};
int main() {
    std::vector<foo> lVec;
    for (int i=0;i<10;i++) {
        lVec.emplace_back(foo(i,i*2,i*4));
    }
    int lPos=0;
    for (auto &rFoo: lVec) {
        std::cout << "Item pos" << lPos++ << " g:" << rFoo.g << " h:" << rFoo.h << " l:" << rFoo.l << std::endl;
    }
    return EXIT_SUCCESS;
}

如果你知道向量的大小并且你想填充它你可以->

#include <iostream>
#include <vector>
struct foo{
    foo(int aG,int aH, int aL):g(aG),h(aH),l(aL) {};
    int g;
    int h;
    int l;
};
int main() {
    std::vector<foo> lVec(10,{0,0,0});
    int lPos = 0;
    for (auto &rFoo: lVec) {
        rFoo = foo(lPos,lPos*2,lPos*4);
        lPos++;
    }
    lPos=0;
    for (auto &rFoo: lVec) {
        std::cout << "Item pos" << lPos++ << " g:" << rFoo.g << " h:" << rFoo.h << " l:" << rFoo.l << std::endl;
    }
    return EXIT_SUCCESS;
}

您可以为您的结构添加一个默认构造函数。新代码看起来像这样:

struct numberOfSpecies {
    numberOfSpecies (): predator(0), prey1(0), prey2(0) { }  // default constructor
    int predator;
    int prey1;
    int prey2;
};
这样，当应用resize时，你的结构将在vector内部正确初始化。
相关文章：