C++ C++；在带有浮点数组的结构的二维向量上使用delete

我有一个这样的结构：

struct foo {

  int a,b,c;

  float d; 

  float *array1;

  float *array;

}; 

vector< vector<foo> > bar(8);
for (int i = 0; i < 8; i++)
    bar[i].resize(8);

delete [] bar[i][j].array1;

现在我将此结构用于8x8二维向量，如下所示：

struct foo {

  int a,b,c;

  float d; 

  float *array1;

  float *array;

}; 

vector< vector<foo> > bar(8);
for (int i = 0; i < 8; i++)
    bar[i].resize(8);

delete [] bar[i][j].array1;

如何正确释放bar使用的内存？

我尝试使用for循环释放每个浮点数组，如下所示：

struct foo {

  int a,b,c;

  float d; 

  float *array1;

  float *array;

}; 

vector< vector<foo> > bar(8);
for (int i = 0; i < 8; i++)
    bar[i].resize(8);

delete [] bar[i][j].array1;

---

但这将导致运行时出现堆异常。

向

结构添加析构函数以清理这些成员

或者，你可以按照爱德华多·莱昂的建议，将它们作为结构的一部分进行分配

float array1[256];

而不是

float *array1;

将析构函数添加到
struct
以清理这些成员

或者，你可以按照爱德华多·莱昂的建议，将它们作为结构的一部分进行分配

float array1[256];

而不是

float *array1;

首先，您应该使用
向量
，而不是
浮点*

第二，释放内存的方法是正确的，错误一定在其他地方。
首先，你应该使用
向量
，而不是
浮点*

其次，您释放内存的方式是正确的，错误一定在其他地方。
您可以发布实际的代码片段吗？如果您只是删除正在分配的元素，那么应该不会有问题

我建议做几件事来缩小范围：

初始化时为所有指针分配NULL
使用共享的\u ptr类型而不是原始的浮点指针-当没有引用保留时，这些指针将自动清除
你能发布一个实际的代码片段吗？如果您只是删除正在分配的元素，那么应该不会有问题

我建议做几件事来缩小范围：

初始化时为所有指针分配NULL
使用共享的\u ptr类型而不是原始的浮点指针-当没有引用保留时，这些指针将自动清除
必须将此析构函数添加到struct foo：

~foo() {
  delete []array1;
  delete []array2;
}

我还建议您为
foo
创建一个构造函数，将这两个指针初始化为0：

foo()
:a(0),b(0),c(0),
 d(0.0), array1(0), array2(0)
{}

必须将此析构函数添加到struct foo：

~foo() {
  delete []array1;
  delete []array2;
}

我还建议您为
foo
创建一个构造函数，将这两个指针初始化为0：

foo()
:a(0),b(0),c(0),
 d(0.0), array1(0), array2(0)
{}

我建议您使用向量或其他stl容器，这符合您的需要

如果必须是数组-最好在结构中使用析构函数，这样就不必考虑手动清理：

  struct foo
  {
    int a,b,c;
    float d; 
    float *array1;
    float *array2;

     foo ()
        : a(0),
        b(0),
        c(0),
        d(0.0),
        array1(NULL),
        array2(NULL)
     { }

     ~foo ()
     {
        delete [] array1;
        delete [] array2;
     }
  }; 

编辑：删除[code>delete[]

上的空检查。我建议您使用适合您需要的向量或其他stl容器

如果必须是数组-最好在结构中使用析构函数，这样就不必考虑手动清理：

  struct foo
  {
    int a,b,c;
    float d; 
    float *array1;
    float *array2;

     foo ()
        : a(0),
        b(0),
        c(0),
        d(0.0),
        array1(NULL),
        array2(NULL)
     { }

     ~foo ()
     {
        delete [] array1;
        delete [] array2;
     }
  }; 

---

编辑：删除[code>delete[]

上的NULL检查。完成此操作的最简单方法是创建构造函数和析构函数：

struct foo {

  int a,b,c;
  float d; 
  float *array1;
  float *array;

  foo()
  {
    array1 = array = 0;
  }

  ~foo()
  {
    delete [] array1;
    delete [] array;
  }

};

更好的方法是让成员跟踪array1&array的大小，以便复制构造函数和/或赋值操作符可以根据需要克隆它们

---

注：我所说的“最简单”并不是指“最好”。）

最简单的方法是创建构造函数和析构函数：

struct foo {

  int a,b,c;
  float d; 
  float *array1;
  float *array;

  foo()
  {
    array1 = array = 0;
  }

  ~foo()
  {
    delete [] array1;
    delete [] array;
  }

};

更好的方法是让成员跟踪array1&array的大小，以便复制构造函数和/或赋值操作符可以根据需要克隆它们

---

注：我所说的“最简单”并不是指“最好”。）浮点数组1（256）；浮动[256]阵列2如果你的数组总是有256个元素，你应该考虑用这种方式声明它们：<代码>浮点数组1（256）；浮动[256]阵列2调用

delete

时不需要检查null。调用

delete

时不需要检查null。