Why do I encounter an error on a simple matrix function - c

Question

I don't understand why my program crashes every time I finish reading and my showing function comes....
The error says read access violation
void read(int **m, int n)
{
int i, j;
for(i=0;i<n;i++)
for (j = 0; j < n; j++)
{
printf("a[%d][%d]=", i, j);
scanf("%d", (m + i * n + j));
}
}
void show(int **m, int n)
{
int i, j;
for (i = 0; i < n; i++)
for (j = 0; j <= n; j++)
{
printf("%d ", *(m + i * n + j));//where the error occurs
printf("\n");
}
}
int main()
{
int **m;
int opt,n;
printf("Introduceti nr de linii si coloane:");
scanf("%d", &n);
m= (int*)malloc(n*n * sizeof(int));

Answer 1

Continuing from my comment, your primary issue is you allocate storage for n * n pointers, but then fail to allocate any storage for the int values. When working with pointers and/or allocating storage dynamically, you should always be able to answer "To what valid storage do each of my pointers point?". If you can't you have no idea what address you are attempting to use.
(note: you only need to allocate n pointers -- one for each row)
As #RetiredNinja also points out, you have an Off-By-One error in for (j = 0; j <= n; j++) which attempts to read the address for n + 1 integer values per row.
Since you have allocated n * n pointers, you now need to allocate storage for n integers assigning the address for each new valid block of memory to each of your pointers in turn. Additionally, in read() since your read with scanf() or allocation with malloc() can fail, you must provide a return type for the read() function that can indicate success or failure. Making the return type int and returning 1 on success or 0 on failure is fine.
(note: since read() conflicts with an existing syscall name, you should rename your read() function, e.g. mtrxread() or the like)
Putting that altogether, you can do something like:
/* type must be capable of indicating success/failure */
int mtrxread (int **m, int n)
{
int i, j;
for (i = 0; i < n; i++) { /* guard each block with {...} */
/* allocate n int / validate EVERY allocation */
if (!(m[i] = malloc (n * sizeof *m[i]))) {
perror ("malloc-m[i]");
return 1;
}
for (j = 0; j < n; j++) {
printf("a[%d][%d] = ", i, j);
if (scanf ("%d", &m[i][j]) != 1) { /* validate EVERY input */
fputs ("error: invalid integer input.\n", stderr);
return 0;
}
}
}
return 1;
}
(note: In C, there is no need to cast the return of malloc, it is unnecessary. See: Do I cast the result of malloc?)
(also fix the <= making it < in show())
In main(), you need to validate EVERY input and EVERY allocation - just as you do everywhere else. You also need to validate whether mtrxread() succeeds or fails. Putting that together, you can do:
int main (void) {
int **m; /* NOT an array, a pointer-to-pointer-to int */
int n;
fputs ("Introduceti nr de linii si coloane: ", stdout);
if (scanf("%d", &n) != 1) { /* validate EVERY input */
fputs ("error: invalid integer input.\n", stderr);
return 1;
}
/* validate EVERY allocation */
if (!(m = malloc (n * sizeof *m))) {
perror ("malloc-m");
return 1;
}
if (!mtrxread (m, n)) { /* validate read of elements */
return 1;
}
show (m, n); /* show the matrix */
for (int i = 0; i < n; i++) {
free (m[i]); /* free int storage */
}
free (m); /* free pointers */
}
(note: the additional information provided by comments in the code)
The complete code could be:
#include <stdio.h>
#include <stdlib.h>
/* type must be capable of indicating success/failure */
int mtrxread (int **m, int n)
{
int i, j;
for (i = 0; i < n; i++) { /* guard each block with {...} */
/* allocate n int / validate EVERY allocation */
if (!(m[i] = malloc (n * sizeof *m[i]))) {
perror ("malloc-m[i]");
return 1;
}
for (j = 0; j < n; j++) {
printf("a[%d][%d] = ", i, j);
if (scanf ("%d", &m[i][j]) != 1) { /* validate EVERY input */
fputs ("error: invalid integer input.\n", stderr);
return 0;
}
}
}
return 1;
}
void show (int **m, int n)
{
int i, j;
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
printf("%d ", m[i][j]);//where the error occurs
}
putchar ('\n'); /* you putchar() a single character */
}
}
int main (void) {
int **m; /* NOT an array, a pointer-to-pointer-to int */
int n;
fputs ("Introduceti nr de linii si coloane: ", stdout);
if (scanf("%d", &n) != 1) { /* validate EVERY input */
fputs ("error: invalid integer input.\n", stderr);
return 1;
}
/* validate EVERY allocation */
if (!(m = malloc (n * sizeof *m))) {
perror ("malloc-m");
return 1;
}
if (!mtrxread (m, n)) { /* validate read of elements */
return 1;
}
show (m, n); /* show the matrix */
for (int i = 0; i < n; i++) {
free (m[i]); /* free int storage */
}
free (m); /* free pointers */
}
Example Use/Output
$ ./bin/ptr2ptr2int-allocate
Introduceti nr de linii si coloane: 3
a[0][0] = 1
a[0][1] = 2
a[0][2] = 3
a[1][0] = 4
a[1][1] = 5
a[1][2] = 6
a[2][0] = 7
a[2][1] = 8
a[2][2] = 9
1 2 3
4 5 6
7 8 9
Memory Use/Error Check
In any code you write that dynamically allocates memory, you have 2 responsibilities regarding any block of memory allocated: (1) always preserve a pointer to the starting address for the block of memory so, (2) it can be freed when it is no longer needed.
It is imperative that you use a memory error checking program to ensure you do not attempt to access memory or write beyond/outside the bounds of your allocated block, attempt to read or base a conditional jump on an uninitialized value, and finally, to confirm that you free all the memory you have allocated.
For Linux valgrind is the normal choice. There are similar memory checkers for every platform. They are all simple to use, just run your program through it.
$ valgrind ./bin/ptr2ptr2int-allocate
==5081== Memcheck, a memory error detector
==5081== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==5081== Using Valgrind-3.18.1 and LibVEX; rerun with -h for copyright info
==5081== Command: ./bin/ptr2ptr2int-allocate
==5081==
Introduceti nr de linii si coloane: 3
a[0][0] = 1
a[0][1] = 2
a[0][2] = 3
a[1][0] = 4
a[1][1] = 5
a[1][2] = 6
a[2][0] = 7
a[2][1] = 8
a[2][2] = 9
1 2 3
4 5 6
7 8 9
==5081==
==5081== HEAP SUMMARY:
==5081== in use at exit: 0 bytes in 0 blocks
==5081== total heap usage: 6 allocs, 6 frees, 2,156 bytes allocated
==5081==
==5081== All heap blocks were freed -- no leaks are possible
==5081==
==5081== For lists of detected and suppressed errors, rerun with: -s
==5081== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
Always confirm that you have freed all memory you have allocated and that there are no memory errors.
Option For Single-Allocation/Single-Free with Pointer to VLA
C provides a, now optional, feature called a Variable Length Array, that in your case can provide a single-allocation/single-free. While this feature was made optional in C11, it will remain widely supported for some time. By using a pointer-to-VLA-of int[n], you can make a single call to malloc() in main() to allocate all storage required. The changes required are:
int main (void) {
int n;
fputs ("Introduceti nr de linii si coloane: ", stdout);
if (scanf("%d", &n) != 1) { /* validate EVERY input */
fputs ("error: invalid integer input.\n", stderr);
return 1;
}
int (*m)[n]; /* pointer to VLA of n int */
/* validate EVERY allocation */
if (!(m = malloc (n * sizeof *m))) {
perror ("malloc-m");
return 1;
}
if (!mtrxread (n, m)) { /* validate read of elements */
return 1;
}
show (n, m); /* show the matrix */
free (m); /* free allocated memory */
}
The order of your parameters for each function will need to change so the size n is known before the pointer to VLA is provided. For example mtrxread() would reduce to:
/* type must be capable of indicating success/failure */
int mtrxread (int n, int (*m)[n])
{
int i, j;
for (i = 0; i < n; i++) { /* guard each block with {...} */
for (j = 0; j < n; j++) {
printf("a[%d][%d] = ", i, j);
if (scanf ("%d", &m[i][j]) != 1) { /* validate EVERY input */
fputs ("error: invalid integer input.\n", stderr);
return 0;
}
}
}
return 1;
}
(change the order for show() in like manner)
Now all memory is allocated at once and requires only a single call to free(). Quite convenient, but with the caveat of the VLA now having optional support from compilers.
Let me know if you have further questions.