使用 C 中的指针进行矩阵加法

Question

Write a program to add 2 m*n matrices using just pointer referencing/dereferencing. That is, no array use allowed. my code is as:

#include<stdio.h>
int main()
{
    int row,col;
    scanf("%d %d",&row,&col);
    int* ptr1;
    int* ptr2 = ptr1 + (row*col);/*if ptr1+(row*col) is not there then runtime error is given*/
    int* ptr3 = ptr2 + (row*col);
    for(int i=1;i<=(row*col);i++)
    {
        scanf("%d",(ptr1+i));
    }
    for(int i=1;i<=(row*col);i++)
    {
        scanf("%d",(ptr2+i));
        *(ptr3+i)=(*(ptr1+i) + *(ptr2+i));
    }
    for(int i=1;i<=(row*col);i++)
    {
        printf("%d ",(*(ptr3+i)));
        if(i%col == 0) printf("\n");
    }
    return 0;
}

problem is that it works fine for upto 3*3 matrices and after that it gives runtime error.

Answer 1

1. You need to allocate space for your arrays on the heap using malloc or similar:

#include <stdlib.h>
...
    int* ptr1 = malloc(3 * (row*col) * sizeof(int));
...

2. Your loops should start at 0 and end at (row*col)-1 .

...
    for(int i=0;i<=(row*col)-1;i++)
...

... or more conventionally:

...
    for(int i=0;i<(row*col);i++)
...

Answer 2

for example, ptr1 point to the offset 0 of the memory system as below, the matrix size if 2x2 .

----- ----- ----- ----- ----- ----- --------------------
|    |     |     |     |     |      |
----- -----  ----- ----- ----- ----- -------------------
0                      16
^                       ^
|                       |
ptr1                   ptr2
<--readable/writable---><--------read-only/write-only---

In this case, you can dereference the pointer to read and write value from offset 0 to 16 . But the problem is when you try to modify the value from the offset 16 that is pointed by ptr2 , those address is read-only or write-only, so the system does not accept you to read or write respectively.

So you have to allocate for ptr1 AT LEAST 3*(row*col)*sizeof(int) (from ptr1 to ptr3+row*col ).

int* ptr1 = malloc(3 * (row*col) * sizeof(int));
if(!ptr1) { // handle the error, because if you cannot allocate the memory, you do not need to do the rest of code.
   return -1; 
}

if you want to do:

    for(int i=1;i<=(row*col);i++)
    {
        printf("%d ",(*(ptr3+i)));
        if(i%col == 0) printf("\n");
    }

You have allocate (3*row*col+1)*sizeof(int) or you can change the iterator of the for loop from 0 to row*col-1 (i recommend this option):

    for(int i=0;i< (row*col);i++)
    {
        printf("%d ",(*(ptr3+i)));
        if(i%col == 0) printf("\n");
    }

Do not forget to free(ptr1) at the end of your program.

Answer 3

1. Where are the matrices defined? Why do you write:

 int row,col;
 scanf("%d %d",&row,&col);
 int* ptr1;  /* <<<WERE DO YOU INITIALIZE THIS ****POINTER**** ???>>> */
 int* ptr2 = ptr1 + (row*col);/*if ptr1+(row*col) is not there then runtime error is given*/  /* <<<BUT YOU ARE USING ITS VALUE HERE !!! >>> */
 int* ptr3 = ptr2 + (row*col);

2. A pointer, in C, is not the same as any kind of array. They have uses that allow you to interchange their roles at some points, but when you dominate the field. Until then, be aware that a pointer and an array are very different things .

Pointer

As you have defined above, you have defined a pointer. A pointer holds the address of something in memory, and so, has only space for one address storage.

Declaration of a pointer:

int *reference;

Array

An array is an object that provides storage for a definite (at compilation time) number of elements, all of them of the same type.

Declaration of an array:

int vector[100]; /* this is an array of 100 ints */

If you want your pointer to point to some of the elements of the array, you can assign it its address, with something like:

reference = &vector[53];

and you can access the element pointed to by reference with:

printf("the 54th element of the array is %d\n", *reference);

or

printf("the 54th element of the array is %d\n", vector[53]);

(as the arrays are zero based, the first element is vector[0] , the second is vector[1] , etc.)

3. The notation *(array + i) is completely nasty. Nobody uses it, except to obscure the code. The correct notation is array[i] , and you should avoid using pointer arithmetic until you have a clear idea of the differences between pointers and arrays.

4. You can use multidimensional arrays, with the following notation:

   • To declare a bidimensional array, eg a 2 rows by three columns array, you use:

int A[2][3];

* You can access its elements (remember, zero based) as `A[0][0]`...`A[0][2]`, `A[1][0]`...`A[1][2]` and stop... no more elements in your array.

Let's see how to initialize and add two such arrays:

#include <stdio.h>

/* declaration and initialization of both matrices A and B */
double A[2][3] = { { 0.0, 1.3, 3.14 }, { 5.6, 4.2, 3.8 } },
       B[2][3] = { {53.0, 42.8, 90.0}, { 2.718, 3.16, 1.4142135} };

/* the following function prints a matrix (of 2 rows by 3 columns) of 
 * name 'name' */
void
print_matrix(char *name, double M[2][3])
{
    printf("Matrix %s:\n", name);
    int row, col;
    for (row = 0; row < 2; row = row + 1) {
        for (col = 0; col < 3; col = col + 1) {
            if (col > 0) printf("\t");
            printf("%8.4f", M[row][col]);
        }
        printf("\n");
    }
    printf("\n");
}

int main()
{
    /* lets print matrix A */
    print_matrix("A", A);
    print_matrix("B", B); /* ... and B */

    double C[2][3]; /* declaration of matrix C */
    int r, c; /* row and column, for the loops */

    /* let's sum all the elements */
    for (r = 0; r < 2; r = r + 1) {
        for (c = 0; c < 3; c = c + 1) {
            C[r][c] = A[r][c] + B[r][c];
        }
    }

    /* and print the results */
    print_matrix("C", C);
    return 0;
}