Question

我尝试用c来理解malloc和动态分配，但是当我编译程序时一切正常，但是如果我运行它终端告诉我分段错误（核心转储）并退出< / p>

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

int main(){
    int **matrice;
    int righe, colonne;
    int r, c;

    printf("Quante RIGHE deve avere la matrice? ");
    scanf("%d", &righe);

    printf("Quante COLONNE deve avere la matrice? ");
    scanf("%d", &colonne);

    matrice = (int**) malloc(righe*colonne*sizeof(int));

    for(r=0; r<righe; r++){
        matrice[r] = (int*) malloc(colonne*sizeof(int));

        for(r=0; r<righe; r++){
            for(c=0; c<colonne; c++){
                printf("Elemento[%d][%d]: ",r, c);
                scanf("%d", &matrice[r][c]);
            }

            // print out
            for(r=0; r<righe; r++){
                for(c=0; c<colonne; c++){
                    printf ("%d\n", matrice[r][c]);
                }
            }
        }
    }
}

Answer 1

您有许多步骤无序，而您为循环填写matrice的顺序不正确。您还缺少所有输入和所有分配的验证。要纠正问题，您可以执行以下操作：

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

int main(){
    int **matrice;
    int righe, colonne;
    int r, c;

    printf("Quante RIGHE deve avere la matrice? ");
    if (scanf("%d", &righe) != 1) {
        fprintf (stderr, "error: invalid input - righe.\n");
        return 1;
    }

    printf("Quante COLONNE deve avere la matrice? ");
    if (scanf("%d", &colonne) != 1) {
        fprintf (stderr, "error: invalid input - colonne.\n");
        return 1;
    }

    matrice = malloc (righe * sizeof *matrice);
    if (!matrice) {
        perror ("matrice");
        return 1;
    }

    for (r = 0; r < righe; r++){
        matrice[r] = malloc (colonne * sizeof *matrice[r]);
        if (!matrice[r]) {
            perror ("matrice[r]");
            return 1;
        }

        for (c = 0; c < colonne; c++){
            printf ("Elemento[%d][%d]: ",r, c);
            if (scanf ("%d", &matrice[r][c]) != 1) {
                fprintf (stderr, "error: matrice[r][c].\n");
                return 1;
            }
        }
    }

    // print out
    for (r = 0; r < righe; r++){
        for (c = 0; c < colonne; c++)
            printf (" %3d", matrice[r][c]);
        putchar ('\n');
        free (matrice[r]);
    }
    free (matrice);
}

注意不要忘记free您分配的内存。

示例使用/输出

$ ./bin/arrmatrice
Quante RIGHE deve avere la matrice? 3
Quante COLONNE deve avere la matrice? 3
Elemento[0][0]: 1
Elemento[0][1]: 2
Elemento[0][2]: 3
Elemento[1][0]: 4
Elemento[1][1]: 5
Elemento[1][2]: 6
Elemento[2][0]: 7
Elemento[2][1]: 8
Elemento[2][2]: 9
   1   2   3
   4   5   6
   7   8   9

仔细看看，如果您有其他问题，请告诉我。

Answer 2

您的帖子中的确切问题已经在评论中回答（现在在接受的答案中），但另一个建议是将 2D 矩阵的分配合并到一个函数中，例如为：

int ** Create2D(int c, int r)
{   
    int **arr;
    int    y;

    arr   = calloc(c, sizeof(int *));
    for(y=0;y<c;y++)
    {
        arr[y] = calloc(r, sizeof(int));    
    }
    return arr;
}

这需要对代码中的循环进行一些架构更改（顺便提一下，这是问题的一部分），并简化整体事情。

使用此代码生成的数组后，应该一如既往地释放它。这可以通过创建单个函数以类似的方式完成：

void free2D(ssize_t **arr, ssize_t c)
{
    int i;
    if(!arr) return;
    for(i=0;i<c;i++)
    {
        free(arr[i]);
        arr[i] = NULL;
    }
    free(arr);
    arr = NULL;
}

例如，用法类似于：

... 
int ** twoDArray = Create2D(colonne, righe);
if(twoDArray)
{ 
   // use array 
   //...
   free2D(twoDArray, colonne);
}
...

Answer 3

你错过了一个“*”并且嵌套错了最后两个循环。我相信这就是你想要的：

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

int main()
{
    int **matrice;
    int righe, colonne;
    int r, c;

    printf("Quante RIGHE deve avere la matrice? ");
    scanf("%d", &righe);

    printf("Quante COLONNE deve avere la matrice? ");
    scanf("%d", &colonne);

    matrice = (int **) malloc(righe * sizeof(int *)); //<<< here

    for(r=0; r<righe; r++)
    {
        matrice[r] = (int *) malloc(colonne * sizeof(int));

        for(c = 0; c < colonne; ++c) //<<< here
        {
            printf("Elemento[%d][%d]: ", r, c);
            scanf("%d", &matrice[r][c]);
        }
    }

    for(r = 0; r < righe; ++r) //<<< here
        for(c = 0; c < colonne; ++c)
            printf ("%d\n", matrice[r][c]);
}

Answer 4

malloc调用是问题，你分配的错误号码字节。

通过指向一个包含指针的数组的指针来创建矩阵数组int。

int **matrix = calloc(rows, sizeof(*matrix));
if(matrix == NULL)
    // handle the error

现在你必须初始化列：

for(int i = 0; i < rows; ++i)
    matrix[i] = calloc(cols, sizeof *matrix[i]);
    if(matrix[i] == NULL)
        // handle the error

现在，您可以按matrix[i][j]访问每个单元格。

释放矩阵也很容易：

for(int i = 0; i < rows; ++i)
    free(matrix[i]);
free(matrix);

请注意，我使用的是calloc而不是malloc。差异（除了使用2个参数代替1）是calloc设置分配的内存当你进行错误处理并想要释放时，这是一个巨大的帮助记忆。 <{1}}不被禁止。

创建free(NULL)和create_matrix等专用函数是一种很好的做法 free_matrix。将所有内容设置为0非常方便。

最后一件事：我建议在致电sizeof(<data type>)时不要使用malloc 和calloc。很容易错过正确的类型，错过*或犯错误一般来说。但是sizeof *var会返回始终正确的数字字节。

用C创建动态矩阵

4 个答案: