create dynamic matrix with C

Question

I try to understand the malloc and dynamic allocation with c, but when I compile the program everything is ok, but if I run it the terminal tells me Segmentation fault (core dumped) and exits

#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

You have a number of steps out of order, and your ordering of you for loops to fill your matrice is incorrect. You also lack validation for all input and all allocation. To correct the problems you can do something like the following:

#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);
}

note don't forget to free the memory you allocate.

Example Use/Output

$ ./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

Look things over and let me know if you have further questions.

Answer 2

The exact issue in your post has been answered in the comments (and now in the accepted answer), but one other suggestion would be to consolidate the allocation of the 2D matrix into a function, such as:

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;
}

This would require some architectural changes to the loops in your code (which, by the way are part of your problem), and simplify things overall.

After using the array this code produces, as always it should be freed. This can be done in similar fashion by creating a single function to do it:

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;
}

Usage, for example would be similar to:

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

Answer 3

You missed a "*" and nested wrong the two last loops. I believe this is what you want:

#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

The malloc calls are the problem, you are allocating the wrong number of bytes.

The matrix is created by having a pointer to an array that holds pointers to arrays of int.

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

Now you have to initialize the columns:

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

Now you can access every cell by matrix[i][j].

Freeing the matrix is also easy:

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

Note that I used calloc instead of malloc. The difference (other than using 2 parameters instead of one) is that calloc sets the allocated memory to 0. This is a huge help when you are doing error handling and want to free the memory. free(NULL) is not forbidden.

It's a good practice to create dedicated functions like create_matrix and free_matrix. There having everything set to 0 is really handy.

Last thing: I recommend not using sizeof(<data type>) when calling malloc and calloc. It's easy to miss the correct type, miss a * or make mistakes in general. sizeof *var however returns always the correct number of bytes.