C program to calculate determinants of matrixes with command line parameters - c

Question

So I have task like this:
"Write a program that will calculate determinants of matrixes. Size of the matrix should be typed as a command line parameter of the program. The user should type the matrix elements from the keyboard once the program is executed. The determinants should be calculated for different square matrix sizes (<=3) and not for the single fixed one. Divide your program into several functions. Use pointers. The size of arrays you'll use is determined by user during the program execution, therefore there is no need to use dynamic memory allocation."
I've heard that it's not possible to do this task with command line parameters, but not dynamic memory allocation. I'm just a beginner, so I wouldn't know. I haven't gotten to the part with calculating the determinants, I only wrote the functions to input and print a matrix, but there are already problems. I'm really lost as to what should I do.
This is what I have so far (it is not compiling right):
void inputMatrix(int size);
void printMatrix(int *matrix, int size);
int main(int argc, char *argv[])
{
int size = atoi(argv[1]);
int *matrix;
inputMatrix(size);
printMatrix(*matrix, size);
return 0;
}
void inputMatrix(int size)
{
int i, j;
int *matrix;
for(i=0; i<size; i++)
{
for(j=0; j<size; j++)
{
scanf("%d", (*(matrix + i) + j));
}
}
}
void printMatrix(int *matrix, int size)
{
int i, j;
int *matrix;
for(i=0; i<size; i++)
{
for(j=0; j<size; j++)
{
printf("%d ", *(*(matrix +i) + j));
}
printf("\n");
}
}

Answer 1

The answer by Joni addresses the main issue, but there are other things to be fixed in OP's code.
For starters, we have to decide whether to use a an array of arrays (like int mat[3][3];) or a simple array (like int mat[9];), while in OP's code, there's some confusion about it:
int main(int argc, char *argv[])
{
// ...
int *matrix; // <-- This pointer is uninitialized, its value is indeterminated
// ...
printMatrix(*matrix, size);
// ^ dereferencing it, you are passing an 'int'
}
// ...
void printMatrix(int *matrix, int size)
{ // ^ a pointer to an int is expected
int i, j;
int *matrix; // <-- This is a local variable that will shadow the parameter
// with the same name and it is also uninitialized.
for(i=0; i<size; i++)
{
for(j=0; j<size; j++)
{
printf("%d ", *(*(matrix +i) + j));
// ^^^^ this is equivalent to 'matrix[i][j]',
// but 'matrix' is only a pointer to 'int'
}
printf("\n");
}
}
So, if any dynamic memory allocation must be avoided, we can write somthing like this:
// ...
#define MAX_SIZE 3
int main(int argc, char *argv[])
{
int matrix[MAX_SIZE][MAX_SIZE];
// read 'size' from command line arguments, then
inputMatrix(size, matrix); // <-- Note that I'm passing 'matrix' here too.
printMatrix(size, matrix);
// ...
}
// The functions must be modified accordingly, e.g.:
void printMatrix(int size, int matrix[][MAX_SIZE])
// The inner dimension must be specified ^^^^^^
{
for(int i = 0; i < size; i++)
{
for(int j = 0; j < size; j++)
{
printf("%d ", *(*(matrix + i) + j)); // <-- "Use pointers." they said
}
printf("\n");
}
}
In case you want to use a plain array instead, it can be written like this:
// ...
#define MAX_SIZE 9 // <-- the total size: 3*3
int main(int argc, char *argv[])
{
int matrix[MAX_SIZE];
// ...
printMatrix(size, matrix);
// ...
}
void printMatrix(int size, int matrix[])
{
for(int i = 0; i < size; i++)
{
for(int j = 0; j < size; j++)
{
printf("%d ", *(matrix + (i * size + j));
// Note the math ^^^^^^^^^^^^^^^^^
// In this simple case of row wise traversal, it could be as simple as
// *(matrix++)
}
printf("\n");
}
}

Answer 2

Since you're not allowed to use dynamic memory allocation, you'll have to create the matrix in the main function and pass it to the other functions as a parameter. This uses a feature of C called variable length arrays:
int matrix[size*size];
inputMatrix(size, matrix);
If variable length arrays are not allowed either, just make it matrix[9] - size is at most 3 in your assignment

Answer 3

Finding determinant of square matrix of order n (n is finite) is quite easy with dynamic memory allocation. But, what is important in this case, is to free the memory at the end of program.
You can view my code here!