C 零或清除动态分配结构元素的有效方法

在for循环中，我希望将动态分配的

struct

传递给函数。在每次迭代中，我希望在下一次迭代和函数调用之前将结构的元素归零或清除。我尝试在循环内移动

malloc

，并在每个循环结束时释放结构，但这并没有清除结构。我还尝试了

memset（counts，0，sizeof（counts））

，但这并没有将元素设置为零

头文件：

typedef struct counts{
    int base_counts[6]; 
    int n1;
    int n2;
    size_t L_tot_bases;
    int L_bad_site;
}counts;

归档

int main(int argc, char *argv[])
{
    int i, row_count = 5;;
    struct counts *bulk_counts;
    bulk_counts = malloc(sizeof(counts));
        for (i = 0; i < row_count; ++i){
            get_counts(bulk_counts);
        }
}


void get_counts(counts *bulk_counts{
  bulk_counts->base_counts[0] = 3;
  ...
}

intmain（intargc，char*argv[]）
{
整数i，行数=5；；
结构计数*批量计数；
批量计数=malloc（sizeof（计数））；
对于（i=0；i基本计数[0]=3；
...
}

您的

memset（）

是正确的方法，绝对会将所有位（以及所有值，因为它们是整数）设置为零。例如：

struct counts *bulk_counts = malloc(sizeof(counts));
for (i = 0; i < row_count; ++i) {
    memset(bulk_counts, 0, sizeof(counts));
    get_counts(bulk_counts);
}

struct counts*bulk_counts=malloc（sizeof（counts））；
对于（i=0；i

同样，无需动态分配，您可以执行以下操作：

for (i = 0; i < row_count; ++i) {
    struct counts bulk_counts = {0}; // all members will be zero
    get_counts(&bulk_counts);
}

for（i=0；i

您的

memset（）

是正确的方法，绝对会将所有位（以及所有值，因为它们是整数）设置为零。例如：

struct counts *bulk_counts = malloc(sizeof(counts));
for (i = 0; i < row_count; ++i) {
    memset(bulk_counts, 0, sizeof(counts));
    get_counts(bulk_counts);
}

struct counts*bulk_counts=malloc（sizeof（counts））；
对于（i=0；i

同样，无需动态分配，您可以执行以下操作：

for (i = 0; i < row_count; ++i) {
    struct counts bulk_counts = {0}; // all members will be zero
    get_counts(&bulk_counts);
}

for（i=0；i

使用calloc（）将是一种方法，它不仅会分配内存，而且还会用零初始化内存，但是内存分配是一项昂贵的操作。 memset方法是正确的选择，它将整个块设置为零

您做错的事情是您没有将指针传递给memset！，应该这样做：

memset(bulk_counts, 0, sizeof(counts))

使用calloc（）将是一种方法，它不仅会分配内存，而且还会用零初始化内存，但是内存分配是一个昂贵的操作。 memset方法是正确的选择，它将整个块设置为零

您做错的事情是您没有将指针传递给memset！，应该这样做：

memset(bulk_counts, 0, sizeof(counts))

---

您可以在C中按值分配整个结构：

for (i = 0; i < row_count; ++i){
    *bulk_counts = ((counts){})
    get_counts(bulk_counts);
}

for（i=0；i

…因此，您需要做的就是从另一个具有所有零成员的结构中分配到

*bulk_counts

。上面的语法使用

counts

文字（缺少的元素自动为零）；您也可以在循环之前创建一个命名的元素，并使用它

---

因为它使用基本赋值，所以它不应该比任何其他方法慢；如果有任何可测量的差异，它应该是最快的（这将是一个相当愚蠢的编译器，它使用次优的代码作为内置功能）。

您可以在C中按值赋值整个结构：

for (i = 0; i < row_count; ++i){
    *bulk_counts = ((counts){})
    get_counts(bulk_counts);
}

for（i=0；i

…因此，您需要做的就是从另一个具有所有零成员的结构中分配到

*bulk_counts

。上面的语法使用

counts

文字（缺少的元素自动为零）；您也可以在循环之前创建一个命名的元素，并使用它

---

因为它使用基本赋值，所以它不应该比任何其他方法慢；如果有任何可测量的差异，它应该是最快的（这将是一个相当愚蠢的编译器，它使用次优的代码作为内置功能）。

使用

calloc（）

而不是

malloc（）

进行分配和

memset（bulk\u计数，0，sizeof*bulk\u计数）

在

free（bulk\u counts）

之前使用

calloc（）

代替

malloc（）

进行分配和

memset（bulk\u counts，0，sizeof*bulk\u counts）

在

free（bulk\u counts）

之前使用模式

memset（bulk\u counts，0，sizeof*bulk\u counts）；

确保不会造成缓冲区overflow@MattMcNabb在这种情况下，缓冲区怎么会发生溢出？如果

bulk\u counts

实际上不是

counts

类型，那么这可能会溢出。我想程序员给出相应的数据类型是显而易见的，但您的方法是安全的。使用模式

memset（批量计数，0，大小*批量计数）；

确保不会造成缓冲区overflow@MattMcNabb在这种情况下，缓冲区怎么会发生溢出？如果

bulk\u counts

实际上不是

counts

类型，那么这可能会溢出。我想程序员给出相应的数据类型是显而易见的，但是的，您的方法是安全的。