C++ 关于C+中结构中数组的初学者问题+；

我想创建一个结构，并将其作为数组在另一个结构中使用。我的问题是，我不知道我想分配多大的数组，我只知道我在函数中一次。我的意思是我想用[]代替一个预先确定的常数，比如10000

我想如果你看一下我的代码，它将是不言自明的。你能帮助我如何使这个代码工作吗？此外，如果您能告诉我我正在询问的主题的名称（是动态数组吗？），以及在哪里可以找到有关此主题的文章/教程，这将对我有很大帮助

下面是我对结构中数组的错误思考方式的代码

#include <iostream>

using namespace std;

struct keyframe {
    bool a;
    int b;
    int c;
};


struct keyframe_file {
    const int num_views;
    const int num_keyframes;
    keyframe keyframes[];
};


int main() {

    keyframe_file my_file;

    my_file.num_views = 1;
    my_file.num_keyframes = 6;

    my_file.keyframes = new keyframe[my_file.num_keyframes];

    my_file.keyframes[0].a = true;
    my_file.keyframes[0].b = 5;
    my_file.keyframes[0].c = 9;

    return 0;

}

#包括
使用名称空间std；
结构关键帧{
布尔a；
int b；
INTC；
};
结构关键帧文件{
const int num_视图；
const int num_关键帧；
关键帧[]；
};
int main（）{
关键帧_文件我的_文件；
my_file.num_views=1；
my_file.num_keyframes=6；
my_file.keyframes=新关键帧[my_file.num_keyframes]；
my_file.keyframes[0]。a=true；
my_file.keyframes[0].b=5；
my_file.keyframes[0].c=9；
返回0；
}

使用

std:：vector

struct keyframe_file {
    const int num_views;
    const int num_keyframes;
    std::vector<keyframe> keyframes;
};

int main() {
    keyframe_file frame;
    frame.keyframes.resize(...);
}

struct keyframe\u文件{
const int num_视图；
const int num_关键帧；
std：：向量关键帧；
};
int main（）{
为文件帧设置关键帧；
frame.keyframes.resize（…）；
}

使用指针并应用于您的结构

int *p;
p = new int;

---

#包括
使用名称空间std；
结构关键帧{
布尔a；
int b；
INTC；
};
结构关键帧文件{
const int num_视图；
const int num_关键帧；
关键帧*关键帧；
};
int main（）{
关键帧_文件我的_文件；
my_file.num_views=1；
my_file.num_keyframes=6；
对于（int i=0；imy_file.keyframes=new keyframe；//您的代码似乎几乎正确，除了两件事：

关键帧
需要是
关键帧*
而不是
关键帧[]
您忘记了删除分配的内存
不完全类型。在C++中，数组必须提供大小，并且大小必须在编译时本身知道。
您正在使用
new
，应该使用指针

但正如@DeadMG已经建议的那样，
std:：vector
仍然是一个更好的选择

顺便说一句，前两个成员在结构中是
const
，这意味着，不能像在代码中那样为它们赋值。它们必须初始化，并使用您希望它们保存的值。这意味着，现在使用
vector
，您必须包含一个构造函数来初始化结构，如下所示结构不再是一个吊舱

struct keyframe\u文件{
const int num_views；//const成员
const int num_关键帧；//const成员
std：：向量关键帧；
关键帧_文件（int nView、int nkeyframes）
：num_视图（nView）、num_关键帧（nkeyframes）、关键帧（nkeyframes）{}
};
关键帧_file my_file（1,6）；//完成！
如果符合您的目的，STL容器（
std:：vector
）很容易成为最佳选择之一—您需要担心的内存管理越少越好

无论如何，看看上面提到的纳瓦兹的结构定义——C++中的动态数组就是指针。但是，在代码中，你已经正确分配了内存，但是你没有释放它（因此它泄漏了）。因为你分配了<代码>新[] /代码>你需要
delete [] my_file.keyframes;

以正确释放内存

调整大小是另一个问题：使用智能实现，数组调整大小可以是一个摊销O（1）操作，这很好。调整大小时，总是需要O（n），因为需要将所有元素复制到不同大小的新数组中，但如果将其复制一半，则会变成O（1）。也就是说，每次需要调整数组大小时，将数组加倍。下面是一个非常快速的示例

void resize()
{
  if(numOfElementsInArray == sizeOfArray)
  {
    ArrayType * arr = new ArrayType[sizeOfArray*2]; // Allocate a double size array
    for(int i=0;i<sizeOfArray;++i)
      currentArray[i] = arr[i];
    delete [] currentArray; // Free memory in old array
    currentArray = arr; // Set the array to our new one
    sizeOfArray *= 2; // Double the size
  }
}

void resize（）
{
if（numElementsInArray==sizeOfArray）
{
ArrayType*arr=新的ArrayType[sizeOfArray*2]；//分配一个双倍大小的数组
对于（int i＝0；i），在C++中使用动态数组时，有一个基本规则，尤其是在结构或类中使用它时，它是为了删除您不再需要的。
如果想使结构动态化，很容易，只需将
[]
替换为
*
，数组就会变得动态，但还没有结束，还有很多工作要做

您必须构造数组并销毁它，并且销毁它是可能的，并且在使用析构函数时非常有用，如下所示：

struct keyframe_file
{
    const int num_views;
    const int num_keyframes;
    keyframe* keyframes;

    ~keyframe_file() // this is the destructor
    {
        delete[] keyframes;
    }
};

<>但是，即使代码在创建变量后，将变量赋值给变量<代码> MyOrthys/Code >，在C++中是非法的，然后你应该使用类代替。
使用带有动态数组的类非常简单和有趣，使您的代码非常好，您不需要知道太多就可以做到这一点，只需了解什么是构造函数，初始值设定项，析构函数，私有和公共，然后继续编写以下代码：

#include <iostream>

using namespace std;

struct keyframe
{
    bool a;
    int b,c;
};

class keyframe_file
{
public:
    keyframe_file(int NV, int NKF):num_keyframes(NKF),num_views(NV)
    {
        keyframes = new keyframe[num_keyframes];
    }
    ~keyframe_file()
    {
        delete[] keyframes;
    }
private:
    const int num_views;
    const int num_keyframes;
    keyframe* keyframes;
};

int main()
{
    keyframe_file my_file(1,6);
    return 0;
}

#包括
使用名称空间std；
结构关键帧
{
布尔a；
int b，c；
};
类关键帧文件
{
公众：
关键帧文件（int NV，int NKF）：num_关键帧（NKF），num_视图（NV）
{
关键帧=新关键帧[num_keyframes]；
}
~keyframe_file（）
{
删除[]个关键帧；
}
私人：
const int num_视图；
const int num_关键帧；
关键帧*关键帧；
};
int main（）
{
关键帧_文件我的_文件（1,6）；
返回0；
}

此代码工作得非常好，它允许您在创建对象（变量）
my\u文件时一次性为常量
num\u视图
和
num\u关键帧
赋值

记住，你是一个C++程序员，为此感到自豪，并使用类而不是结构A
void resize()
{
  if(numOfElementsInArray == sizeOfArray)
  {
    ArrayType * arr = new ArrayType[sizeOfArray*2]; // Allocate a double size array
    for(int i=0;i<sizeOfArray;++i)
      currentArray[i] = arr[i];
    delete [] currentArray; // Free memory in old array
    currentArray = arr; // Set the array to our new one
    sizeOfArray *= 2; // Double the size
  }
}

struct keyframe_file
{
    const int num_views;
    const int num_keyframes;
    keyframe* keyframes;

    ~keyframe_file() // this is the destructor
    {
        delete[] keyframes;
    }
};

#include <iostream>

using namespace std;

struct keyframe
{
    bool a;
    int b,c;
};

class keyframe_file
{
public:
    keyframe_file(int NV, int NKF):num_keyframes(NKF),num_views(NV)
    {
        keyframes = new keyframe[num_keyframes];
    }
    ~keyframe_file()
    {
        delete[] keyframes;
    }
private:
    const int num_views;
    const int num_keyframes;
    keyframe* keyframes;
};

int main()
{
    keyframe_file my_file(1,6);
    return 0;
}

#include <iostream>

using namespace std;

struct keyframe {
    bool a;
    int b;
    int c;
};


struct keyframe_file {
    const int num_views;
    const int num_keyframes;
    keyframe* keyframes;
};


int main()
{
    keyframe_file my_file = {1, 6};  // initialization needed bcause of 'const int'

    my_file.keyframes = new keyframe[my_file.num_keyframes];

    for (int i = 0; i < my_file.num_keyframes; i++)
    {
        my_file.keyframes[i].a = true;
        my_file.keyframes[i].b = 5 + i;
        my_file.keyframes[i].c = 9 - i;
    }
    return 0;
}