Arrays 将free（）用于结构（两个分配）C中的float**

我和我的研究学院正在尝试在redpitaya（传感器组合）上实现CNN，因此具有有限/无实际调试选项（通过UDP和LED发送一些信息）。 我们在让

free（）

正常工作方面遇到问题。 问题是，我们必须使用结构，并且有大量未定义的传入特性。我们希望为结构中的错误和其他变量分配内存（到目前为止似乎有效）。但是如果我们试图使用

free（）

释放分配的内存，程序就会崩溃。 我不确定如何正确地将存储在

name\u t.error[I]

中的参数（？）传递到

free（）

。 我们尝试了

&

、

*

和

[]

的几种组合，但都不起作用。 我们不是IT专业的学生，所以这有点超出了我们的能力

#define a
//global
struct {
    ...
    float** error;
    ...
} name_t;
name_t var;

main()

init(name_t* f_var, int s1, int s2)
{
    //s1 and s2 not used in the example
    ...
    f_var->error = (float**)malloc(a*sizeof(float));
    ...
    for(){
        f_var->error[i]=(float*)malloc(b*sizeof(float));
        ...
    }

}
//free() ?
free_func(name_t* f_var)
{
    for()
    {
        free(f_var->error[i]);
        ...
    }
    free(f_var->error);
}
//no debugging possible!

最小Exmample

#define a 2

//global
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
typedef struct {
    int i;
    float** error;

} name_t;
name_t var;
int init(name_t* f_var, int s1, int s2);
int free_func(name_t* f_var);
int main()
{
    int x;
    x = init(&var, 1,1);
    free_func(&var);
    return 0;
}

int init(name_t* f_var, int s1, int s2)
{
    //s1 and s2 not used in the example
    f_var->error = (float**)malloc(a*sizeof(float));
//b an array for the layersize which differs for each layer
    for(int i=0; i<a;i++){
        f_var->error[i]=(float*)malloc(b[i]*sizeof(float)); 
    }
    for(int j=0;j<a;j++)
    {
        for(int k=0;k<b;k++)
        {
            f_var->error[j][k]=((float)rand() / RAND_MAX - 0.5);
        }
    }
    return 0;
}
//free() ?
int free_func(name_t* f_var)
{
    for(int i=0; i<b;i++)
    {
        free(f_var->error[i]);
        if (f_var->error[i]!=NULL)return -1;
    }
    free(f_var->error);
    //if (f_var->error!=NULL)return -1; not needed
    return 0;
}

#定义一个2
//全球的
#包括
#包括
#包括
#包括
类型定义结构{
int i；
浮动**错误；
}姓名;；
name_t var；
int init（name_t*f_var，int s1，int s2）；
int free_func（name_t*f_var）；
int main（）
{
int x；
x=初始值（&var，1,1）；
自由函数（&var）；
返回0；
}
int init（name_t*f_var，int s1，int s2）
{
//示例中未使用s1和s2
f_var->error=（float**）malloc（a*sizeof（float））；
//b层的数组Size，每层不同
对于（inti=0；ierror[i]=（float*）malloc（b[i]*sizeof（float））；
}
对于（int j=0；jerror[i]！=NULL）返回-1；
}
自由（f_var->错误）；
//if（f_var->error！=NULL）返回-1；不需要
返回0；
}

这里有一个错误：

f_var->error = (float**)malloc(a*sizeof(float));

应该是

f_var->error = (float**)malloc(a*sizeof(float*));

如果

sizeof（float*）

为8，则只会分配所需内存的一半，从而在访问另一半时导致崩溃

一些提示：

• 不强制转换malloc（）的结果
• 使用

  sizeof*XXX

  当

  XXX

  被指定为变量时，这将在

  f\u var->error

  的类型更改时有所帮助

这里有一个错误：

f_var->error = (float**)malloc(a*sizeof(float));

应该是

f_var->error = (float**)malloc(a*sizeof(float*));

如果

sizeof（float*）

为8，则只会分配所需内存的一半，从而在访问另一半时导致崩溃

一些提示：

• 不强制转换malloc（）的结果
• 使用

  sizeof*XXX

  当

  XXX

  被指定为变量时，这将在

  f\u var->error

  的类型更改时有所帮助

---

通过使用指针数组数据结构而不是数组，您正在使内存分配和释放变得更慢、更大、更复杂。这本身并不是问题的根源，但所需的更复杂的代码确实会为错误留下更多的空间

您正在强制转换

malloc（）

的返回值。这在C中是不必要的，并且可能会掩盖错误。不要这样做。事实上，任何用于算术以外目的的强制转换都有一些代码味道。不过，这也不是您的问题的原因

您没有检查分配失败。这可能与您的问题有关，但在

init（）

中比在

free\u func（）

中更可能导致失败

您对

f\u var->error

的顶级分配可能分配的空间不足。这

…为

a

对象分配足够的空间，该对象的大小为

浮点

，但您需要空间来容纳这么多的

浮点*

。在许多系统上，指针大于

浮点

s。这可以解释您观察到的故障。您可以通过根据对象接收来表示所需的大小来避免此类错误g指针：

    f_var->error = malloc(a * sizeof(*f_var->error));

当然，这对于接收变量类型的更改也是有弹性的

您的

free\u func

假设

free（）

会以某种方式改变作为其参数显示的对象的值。它不能也不会。在C中，所有函数参数都是按值传递的，因此

free（）

即使需要，也无法更改其参数的值。除非开始时该值为null，否则以后不得使用该值。尤其是，除非之前该值为null，否则不能期望该值为null。如果要将其设为null，则需要自己执行。此问题将导致您的特定

free\u func

提前终止，而不释放所有内容。这可能会造成内存泄漏，这可能与故障有关

---

假设在完整的代码中，您的

b

确实是一个扩展为常量表达式的宏，我建议改为：

#include <stdlib.h>

#define b 4
// ...
typedef struct {
    int i;
    float (*error)[b]; // array of arrays style
} name_t;

// ...

int init(name_t* f_var, int s1, int s2) {
    // only one malloc needed
    f_var->error = malloc(a * sizeof(*fvar->error));
    if (!f_var->error) return 1;  // malloc failed

    for (int j = 0; j < a; j++) {
        for (int k = 0; k < b; k++) {
            f_var->error[j][k] = ((float)rand() / RAND_MAX - 0.5);
        }
    }

    return 0;
}

int free_func(name_t* f_var) {
    // only one free needed
    free(f_var->error);
    fvar->error = NULL;

    return 0;
}

#包括
#定义b 4
// ...
类型定义结构{
int i；
float（*error）[b]；//数组的数组样式
}姓名;；
// ...
int init（name_t*f_var，int s1，int s2）{
//只需要一个malloc
f_var->error=malloc（a*sizeof（*fvar->error））；
如果（！f_var->error）返回1；//malloc失败
对于（int j=0；jerror[j][k]=（（float）rand（）/rand_MAX-0.5）；
}
}
返回0；
}
int free_func（name_t*f_var）{
//只需要一个免费的
自由（f_var->错误）；
fvar->error=NULL；
返回0；
}

通过使用指针数组数据结构而不是数组，您正在使内存分配和释放变得更慢、更大、更复杂。这本身并不是问题的原因，但所需的更复杂的代码确实会为错误留下更多的空间

您正在强制转换

malloc（）

的返回值。这在C中是不必要的，并且可能会掩盖错误。不要这样做。事实上，任何用于算术以外目的的强制转换都有一些代码味道。不过，这也不是您的问题的原因

您没有检查分配失败。这可能与您的问题有关，但在

init（）

中比在

free\u func（）

中更可能导致失败

您的顶级配置