c - 对于二维动态分配数组的循环错误

标签 c arrays pointers dynamic allocation

我在将值写入动态分配的二维数组时遇到问题。它似乎在不应该的时候将值写入数组中的其他位置。

据我所知，我已经正确分配了内存，而且我不认为我的迭代已关闭。

当我尝试将数组定义为 double KAB[3][15]={0.0} 时，我没有遇到这个问题。

在这个例子中，很明显，我使用了特定长度的数组，但我希望它们在用户定义时起作用。任何故障排除建议将不胜感激。 

#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <time.h>
#include <string.h>



int main( ) 
{

int ms=0,i=0,j=0,n=0;
double value=0;
    double **KAB;
    KAB = (double **) malloc(3 * sizeof(double **));//makes array of pointers
    for(i = 0; i < 15; i++)
    {
        KAB[i] =(double *) malloc(3 *sizeof(double*));//each pointer points to a certain number of doubles
    }

        for(i=0;i< 3;i++)
        {
            for(j=0;j< 15;j++)
            {
                KAB[i][j]=0.0;//each value is set to 0.
            }
        }

for(ms=0; ms < 3; ms++)
{   
    for(i=0; i<15;i++)
    {       
        value=0;
        for(n=0; n<5 ;n++)
        {
                value+=ms*1.0+1;    
        }
        KAB[ms][i]=value;

        printf("Step:%d MS:%d\n",i,ms);
        printf("KAB[0][7]=%lf KAB[1][7]=%lf KAB[2][7]=%lf\n",KAB[0][7],KAB[1][7],KAB[2][7]);
    }
    }

return 0;
}//ends main

我已经包含了带有一些注释的相关输出。

MS:0 Step:0
KAB[0][7]=0.000000, KAB[1][7]=0.000000, KAB[2][7]=0.000000
MS:0 Step:1

一切都从 0 开始。第一个值放在正确的位置。

MS:0 Step:7
KAB[0][7]=5.000000, KAB[1][7]=0.000000, KAB[2][7]=0.000000

但是在 ms=0 循环结束之前，一些东西被写入了数组的第二行

MS:0 Step:11
KAB[0][7]=5.000000, KAB[1][7]=5.000000, KAB[2][7]=0.000000

在 ms=1 循环的第三步中，第一行被覆盖

MS:1 Step:3
KAB[0][7]=10.000000, KAB[1][7]=5.000000, KAB[2][7]=0.000000

在适当的步骤中，第二行第七列的值得到输入的正确值

MS:1 Step:7
KAB[0][7]=10.000000, KAB[1][7]=10.000000, KAB[2][7]=0.000000

但在该行的其余部分完成之前，相同的值将被放入同一列的下一行。

MS:1 Step:11
KAB[0][7]=10.000000, KAB[1][7]=10.000000, KAB[2][7]=10.000000

第二行被第三行的一些值替换

MS:2 Step:3
KAB[0][7]=10.000000, KAB[1][7]=15.000000, KAB[2][7]=10.000000

第三行获得正确的值。这些值一直保留到最后，但显然第一行和第二行有一些不正确的值。

MS:2 Step:7
KAB[0][7]=10.000000, KAB[1][7]=15.000000, KAB[2][7]=15.000000

最佳答案

在为您的指针分配后，您未能为每一行分配足够的存储空间。 (你有一个魔数(Magic Number)问题)

在解决分配问题之前，让我们看一下有关在代码中使用魔数(Magic Number) 的一般问题。例如，在:

    KAB = (double **) malloc(3 * sizeof(double **));//makes array of pointers
    for(i = 0; i < 15; i++)

3 和 15 是魔数(Magic Number)(这意味着如果有任何变化并且您需要调整分配或循环限制，您只能通过代码来查找每个分配和调整每个循环限制，每个声明大小等...

不要使用魔数(Magic Number)，例如

#define ROW     3   /* if you need a constant, #define one (or more) */
#define COL    15
#define NVAL    5
...
    for (int ms = 0; ms < ROW; ms++) {              /* for each row */

        kab[ms] = calloc (COL, sizeof *kab[ms]);    /* allocate storage */

在您的情况下，您的行分配中有错误的魔数(Magic Number)，例如

for(i = 0; i < 15; i++)
{
    KAB[i] =(double *) malloc(3 *sizeof(double*));
}

您只分配了 3-pointers，但是您随后尝试分配存储空间以用于 3 个 double* 到 15-pointers。从 KAB[3] 开始，您调用了未定义的行为(因为您已经使用了 3 个分配的指针)，并且代码的定义操作结束了。

使用常量代替魔数(Magic Number) 有助于避免这个问题。此外，如果需要更改任何内容，您可以在源文件顶部的一个方便位置进行更改。

为值分配指针和存储空间

当您使用pointer-to-pointer-to-type 作为基类型进行分配时，您必须

  1. 分配一个指针来保存每一行的内存地址；和
  2. 为每一行分配存储空间以保存值

(您还必须验证每个分配，malloc、calloc 和 realloc 可以并且确实会在内存耗尽时失败)

接下来，由于您循环将 kab 行值归零为零，只需使用 calloc 进行分配，它既分配内存又将内存设置为零。

(不要使用 UPPPER 大小写变量名(为常量和宏保留)，也不要使用 camelCase 或 MixedCase 变量-(将那些留给 Java 或 C++))

所以你对指针和行的分配看起来像这样:

...
int main (void) {

    double **kab = NULL;

    /* calloc allocates and initializes memory all zero */
    kab = calloc (ROW, sizeof *kab);    /* use dereference pointer to
                                         * determine typesize */

    if (!kab) {     /* validate every allocation by checking the return */
        perror ("calloc-kab");  /* handle error */
        exit (EXIT_FAILURE);
    }

    for (int ms = 0; ms < ROW; ms++) {              /* for each row */

        kab[ms] = calloc (COL, sizeof *kab[ms]);    /* allocate storage */
        if (!kab[ms]) {                             /* validate allocation */
            perror ("calloc-kab[ms]");              /* handle error */
            exit (EXIT_FAILURE);
        }
...

(不需要强制转换malloc的返回值，没有必要。参见:Do I cast the result of malloc?)

您现在已经为您的行值分配了指针和存储空间，并将其设置为零(通过使用 calloc)，您可以使用二维索引符号自由地寻址和填充您的值。

将所有部分放在一起，您可以执行类似于以下操作的操作:

#include <stdlib.h>
#include <stdio.h>

#define ROW     3   /* if you need a constant, #define one (or more) */
#define COL    15
#define NVAL    5

int main (void) {

    double **kab = NULL;

    /* calloc allocates and initializes memory all zero */
    kab = calloc (ROW, sizeof *kab);    /* use dereference pointer to
                                         * determine typesize */

    if (!kab) {     /* validate every allocation by checking the return */
        perror ("calloc-kab");  /* handle error */
        exit (EXIT_FAILURE);
    }

    for (int ms = 0; ms < ROW; ms++) {              /* for each row */

        kab[ms] = calloc (COL, sizeof *kab[ms]);    /* allocate storage */
        if (!kab[ms]) {                             /* validate allocation */
            perror ("calloc-kab[ms]");              /* handle error */
            exit (EXIT_FAILURE);
        }

        for (int i = 0; i < COL; i++ ) {    /* for each column */
            double value = 0;

            for (int n = 0; n < NVAL; n++)  /* loop NVAL times */
                value += ms * 1.0 + 1;      /* build value */

            kab[ms][i] = value;             /* assign value to kab[ms][i] */
        }
    }

    for (int ms = 0; ms < ROW; ms++) {      /* for each row */
        for (int i = 0; i < COL; i++)       /* for each col */
            printf (" %4.1lf", kab[ms][i]); /* output value */
        putchar ('\n');     /* tidy up */
        free (kab[ms]);     /* free row */
    }
    free (kab);             /* free pointers */

    return 0;
}

示例使用/输出

如何构建 value 以存储在每一列中有点无趣，但对于示例而言它很好。

$./bin/arraydyn2d
  5.0  5.0  5.0  5.0  5.0  5.0  5.0  5.0  5.0  5.0  5.0  5.0  5.0  5.0  5.0
 10.0 10.0 10.0 10.0 10.0 10.0 10.0 10.0 10.0 10.0 10.0 10.0 10.0 10.0 10.0
 15.0 15.0 15.0 15.0 15.0 15.0 15.0 15.0 15.0 15.0 15.0 15.0 15.0 15.0 15.0

内存使用/错误检查

在您编写的任何动态分配内存的代码中，您对分配的任何内存块负有 2 个责任:(1) 始终保留指向起始地址的指针内存块，因此，(2) 它可以在不再需要时被释放。

您必须使用内存错误检查程序来确保您不会尝试访问内存或写入超出/超出您分配的 block 的边界，尝试读取或基于未初始化的值进行条件跳转，最后, 以确认您释放了所有已分配的内存。

对于 Linux valgrind 是正常的选择。每个平台都有类似的内存检查器。它们都易于使用，只需通过它运行您的程序即可。

$ valgrind ./bin/arraydyn2d
==15774== Memcheck, a memory error detector
==15774== Copyright (C) 2002-2015, and GNU GPL'd, by Julian Seward et al.
==15774== Using Valgrind-3.12.0 and LibVEX; rerun with -h for copyright info
==15774== Command: ./bin/arraydyn2d
==15774==
  5.0  5.0  5.0  5.0  5.0  5.0  5.0  5.0  5.0  5.0  5.0  5.0  5.0  5.0  5.0
 10.0 10.0 10.0 10.0 10.0 10.0 10.0 10.0 10.0 10.0 10.0 10.0 10.0 10.0 10.0
 15.0 15.0 15.0 15.0 15.0 15.0 15.0 15.0 15.0 15.0 15.0 15.0 15.0 15.0 15.0
==15774==
==15774== HEAP SUMMARY:
==15774==     in use at exit: 0 bytes in 0 blocks
==15774==   total heap usage: 4 allocs, 4 frees, 384 bytes allocated
==15774==
==15774== All heap blocks were freed -- no leaks are possible
==15774==
==15774== For counts of detected and suppressed errors, rerun with: -v
==15774== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)

始终确认您已释放所有分配的内存并且没有内存错误。

检查一下，如果您还有其他问题，请告诉我。

关于c - 对于二维动态分配数组的循环错误，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/52349750/

上一篇：Android - 如何在 Windows 上构建 native 库并在 Android NDK 中使用它

下一篇：c - 设置进程组阻止子进程启动

相关文章：

c - C 中的结构问题

c - 在 C 程序中，我尝试使用 ECB 模式加密 AES 128

c - 作为函数参数的后缀和前缀运算符——为什么会这样？

c - 使用 fscanf 读取文件

php - 正在打印的值仅属于 array[0]

c# - 位置0处无行错误处理

java - 为什么要两次使用 new 关键字来创建对象数组

c - 在C中动态分配内存给常量char指针？

c++ - 内存集区别？

C 头文件错误 : expected identifier or ‘(’ before ‘[’ token

©2024 IT工具网  联系我们