How do I access the memory using pointers for a multidimensional array?

Question

I have been learning memory allocation and pointers lately, and I made this program which will ask the user to input the dimensions of a matrix and enter it's elements, after which it displays the elements in a matrix format. Here's the code that I've typed.

#include"stdio.h"
#include"stdlib.h"

int *minput();

int *minput(int x,int y)
{
    int *M;
    M=(int*)malloc(x*y*sizeof(int));
    for(int i=0;i<=(x-1);i++)
    {
        for(int j=0;j<=(y-1);j++)
        {
            printf("A(%d,%d)=",i+1,j+1);
            scanf("%d",(M+i+j));
        }
    }
    return M;
}

int main()
{
    int *A,a,b;
    printf("Matrix is (m*n)\n\n");
    printf("m=");
    scanf("%d",&a);
    printf("n=");
    scanf("%d",&b);
    A=minput(a,b);
    printf("\n");

    for(int k=0;k<=(a-1);k++)
    {
        for(int l=0;l<=(b-1);l++)
        {
            printf("%d ",*(A+k+l));
        }
        printf("\n");
    }
    free(A);
    return 0;
}

However when I gave my inputs, I got this:

Matrix is (m*n)

m=3
n=3
A(1,1)=1
A(1,2)=2
A(1,3)=3
A(2,1)=4
A(2,2)=5
A(2,3)=6
A(3,1)=7
A(3,2)=8
A(3,3)=9

1 4 7
4 7 8
7 8 9

What's wrong? Amn't I supposed to get

1 2 3
4 5 6
7 8 9

Is there anything I had made wrong in my code?

Answer 1

You get incorrect output because *(A+k+l) is not the right way of accessing matrix element at matrix[k][l].

For addressing a matrix stored as a "flat" array you need to multiply the value of one of the indexes by the size of the opposite dimension. Depending on which index you multiply you get either a row-major order or a column-major order.

You need to apply the same fix to (M+i+j) inside minput function.

// Input
scanf("%d",(M+y*i+j));
...
// Output
printf("%d ",*(A+b*k+l));

The idea behind multiplying k by b is to make k "count faster". For each increment of k by 1 you need to skip an entire row of b elements. In your three-column matrix example, if you would like to access elements at A[k][0] (the initial column) of your matrix for each row, your index would count by three: 0, 3, 6. This is accomplished by multiplying k by b. The rest is the same as the usual pointer arithmetic: *(A+b*k+l) is equivalent to A[b*k+l].

Demo.