first index to matrix is ignored

Question

I am trying to see if a 4x4 matrix is symmetric, and below is what i have so far. Upon compiling I receive the message:

pExam3p2.c:12:13: warning: expression result unused [-Wunused-value]  
                                if (Num[r,c]==Num[c,r]){  
                                        ^
pExam3p2.c:12:23: warning: expression result unused [-Wunused-value]
                                if (Num[r,c]==Num[c,r]).

I thought that adding an else statement would resolve this issue. But it does not. Any ideas is greatly appreciated. Thank you!

#include <stdio.h>
char isSymm (int Num[][4], int rows, int cols){
    int r,c, count=0;

    for (r=0; r<rows; r++){
        for (c=0; c<cols; c++){
            if (Num[r,c]==Num[c,r]){
                count=count+1;
            }
            else{
                count=count;
            }
        }
    }
    if (count==16){
        return 'y';
    }
    else {
        return 'n';
    }
}

int main (void){
    int Num[4][4];
    int c;
    int r;
    int size =4;

    for (r=0;r<size; r++){
        for (c=0; c<size; c++){
            printf("Enter your number: ");
            scanf("%d", &Num[r][c]); //NOTE THE &...
        }
    }

    char result= isSymm(Num, 4, 4);
    printf("%c", result);
}

You might want to consider using modern C tricks such as `char isSymm (int rows, int cols, int Num[rows][cols])` — Lundin, Jun 04 '18 at 06:55

Some programmer dude · Answer 1 · 2018-06-04T06:33:15.510

Num is not a "multi-dimensional" array (C doesn't have those), it's an array of arrays. So to get an element of it you need to do e.g. Num[r][c].

To explain what happens with Num[r,c], you need to learn about the comma operator.

The comma operator evaluates both sub-expressions, and throw away the result of the left-hand expression and the result is the result of the right-hand expression. So with r,c both r and c are evaluated, and then the result of r is discarded and the result of r,c is c.

That means your expression Num[r,c] is really Num[c]. And Num[c] is an array, which decays to a pointer to its first element, i.e. &Num[c][0], and you compare those two pointers.

On an unrelated note,

else{
    count=count;
}

is practically worthless, and you could remove it completely.

Yunnosch · Answer 2 · 2018-06-04T06:36:29.710

2

In order to access an array of arrays use

Num[r][c]

The , operator which you used does evaluate the part before the , but ignores the result. The result of the operator is the value of the second evaluated expression, the one after the ,.
That is why the compiler tells you that r is ignored.

edited Jun 04 '18 at 06:36

answered Jun 04 '18 at 06:27

Yunnosch

26,130
9
42
54

score 0 · Answer 3 · answered Jun 04 '18 at 06:35

0

Change (Num[r,c]==Num[c,r]) to (Num[r][c]==Num[c][r])

Also remove else statement.

else{
    count=count;
}

answered Jun 04 '18 at 06:35

Gor Asatryan

904
7
24

score 0 · Answer 4 · answered Jun 04 '18 at 06:49

An element in a two-dimensional array is accessed by using the subscripts, i.e., row index and column index of the array. For example :-

int val = a[2][3];

The above statement will take the 4th element from the 3rd row of the array.

So in your function char isSymm (int Num[][4], int rows, int cols) some changes are to be made:-

char isSymm (int Num[][4], int rows, int cols){
    int r,c, count=0;

    for (r=0; r<rows; r++){
        for (c=0; c<cols; c++){
            if (Num[r][c]==Num[c][r]){        // not  Num[r,c]==Num[c,r]
                count=count+1;
            }                                 // not needed count=count; else statement.
        }
    }
    if (count==16){
        return 'y';
    }
    else {
        return 'n';
    }
}

The comma-operator evaluates both sub-expressions, and throw away the result of the left-hand expression and the result is the result of the right-hand expression. So with r,c both r and c are evaluated, and then the result of r is discarded and the result of r,c is c.Here it becomes Num[c] which is invalid since Num is 2-Dimentional array.

score 0 · Answer 5 · answered Jun 04 '18 at 06:54

The problametic statement is Num[r,c]==Num[c,r] & why its so, its informed by compiler when you run gcc -Wall -Wstrict-prototypes -Werror test.c as

error: left-hand operand of comma expression has no effect [-Werror=unused-value]

In Num[r,c] there is comma operator between r and c and comma operator property is that it will solve all argument but consider only right hand operands, so Num[r,c] results in Num[c] and now you are comparing pointers Num[c] and Num[r] which will not yield in correct result.

You wanted to check if matrix is symmetric or not for that this

Num[r,c]==Num[c,r] ==> Num[r][c] == Num[c][r]

And since Num is symmetric matrix. You should calculate number of rows so that it works for any array, not hard coded like size=4.

size=4; ==> size = sizeof(Num)/sizeof(Num[0]);

And while comparing Num[r][c] and Num[c][r] the else part is useless, better remove it.

else{ /* not needed as if if block is false count value doesn't need to change */
    count=count;
}

first index to matrix is ignored

5 Answers5