Issue with returning a 2 dimensional array - c

Question

I was asked to write a program that gets a two dimensional array (a matrix), number of columns,and number of rows, and the program will return the transpose matrix (without using a [][], meaning only using pointer arithmetics)
The program I wrote, does indeed transpose the matrix, it is no problem. My problem is understanding how to return. here's my code:
int** transpose_matrix(matrix mat1,int number_of_rows,int number_of_columns)
{
matrix mat2;
int row_index,column_index;
for(row_index=0;row_index<number_of_rows;row_index++)
{
for(column_index=0;column_index<number_of_columns;column_index++)
**(mat2+(column_index*number_of_rows)+row_index)=**(mat1+(row_index*number_of_columns)+column_index);
}
// at this point, mat2 is exactly the transpose of mat1
return mat2;
}
now here's my problem: I can't return a matrix, closest thing I can do is return the address of the first value of the matrix, but even if i do that, all the rest of the matrix will be unusable as soon as i exit transpose_matrix function back into void main...How can I return mat2?

Answer 1

One, a two-dimensional array is not a double pointer.
Two, dynamic allocation. If matrix is a two-dimensional array type, then write something like this:
typedef int matrix[ROWS][COLUMNS];
typedef int (*matrix_ptr)[COLUMNS];
matrix_ptr transpose_matrix(matrix m, int rows, int cols)
{
matrix_ptr transposed = malloc(sizeof(*transposed) * rows);
// transpose, then
return transposed;
}

Answer 2

OK: Here you have 3 thing:
You cannot return a pointer to a local variable (it will be garbage
after return and the stack (memory) where it was is reused).
Array decay to pointer to the first element when passed.
Pointer arithmetic: p+1 increment the adress in p by sizeof(*p), so
p point to the next element, not to the next byte.
The simple fix for your code (this works for any matrix size) :
int* transpose_matrix(int *mat1,int number_of_rows,int number_of_columns)
{
int *mat2=malloc(number_of_rows*number_of_columns*sizeof(int));
int row_index,column_index;
for(row_index=0;row_index<number_of_rows;row_index++)
{
for(column_index=0;column_index<number_of_columns;column_index++)
mat2[column_index*number_of_rows+row_index]=mat1[row_index*number_of_columns+column_index];
}
// at this point, mat2 is exactly the transpose of mat1
return mat2;
}
...
print(m,r,c); // I hope you have a print()
int *t=transpose_matrix(m,r,c);
print (t,c,r);
...
// use t[max: c-1][max: r-1]
free(t);
If we have only fixed size matrix (well with C99 we can use varable length array too!).
typedef int Matrix[ROWS][COLUMNS];
typedef int TMatrix[COLUMNS][ROWS];
typedef int (*pMatrix)[COLUMNS];
typedef int (*pTMatrix)[ROWS];
pTMatrix transpose_matrix(Matrix m , int rows, int cols)
{
pTMatrix t = malloc(sizeof(*t)*cols);
for (int r=0; r<rows ; ++r)
for (int c=0; r<cols ; ++r)
t[c][r]=m[r][c];
return t;
}
Well, if rows and cols are fixed you dont need to pass it.... hmmm...