C: Why do array elements need to be scanned by memory address?

Let's replace i

with 0. here for an explanation.

scanf("%d", arre[0]);

      

        
        
        
      

    

This code goes to the array, looks at the first element and finds it 17 (or whatever), so it passes 17 as the second argument to scanf()

. But it scanf()

expects a pointer, so it gets terribly confusing when it sees 17 and ends up crashing your application.

scanf("%d", &arre[0]);

      

        
        
        
      

    

This code calculates the location of the first element in the array and passes that pointer to scanf()

. scanf()

happily writes the value to the memory addressed by that pointer.

C passes all arguments to a function by value, which means that the formal parameter in the function definition is a different object in memory from the actual parameter in the function call. Take a look at the following example:

void swap( int a, int b ) { int tmp = a; a = b; b = tmp; }

void foo( void )
{
  int x = 1, y = 2;
  swap( x, y );
  printf( "x = %d, y = %d\n", x, y );
}

      

        
        
        
      

    

The formal parameter a

in swap

is a different object in memory than x

in foo

, so any change we make to a

does not affect x

; after the call, the swap

values x

and y

remain unchanged.

For the function to swap

change the values x

and y

, we must pass pointers to these variables:

void swap( int *a, int *b ) { int tmp = *a; *a = *b; *b = tmp; }

void foo( void )
{
  int x = 1, y = 2;
  swap( &x, &y );
  printf( "x = %d, y = %d\n", x, y );
}

      

        
        
        
      

    

This time, instead of passing values ​​to x

and y

to, swap

we pass addresses x

and y

. The variables a

and b

are pointers to x

and, y

respectively, so writing to an expression is the *a

same as writing to x

(similarly, writing to an expression *b

is the same as writing to y

).

An abbreviated way to describe it

a == &x  --> *a == x
b == &y  --> *b == y

      

        
        
        
      

    

When you call scanf

with an argument arre[i]

, you are passing the value of that array element to the function. Unfortunately, it scanf

wants the address of this element so that it can write a new value to it. scanf

tried to interpret the value you sent as the address of an object in memory hence segfault.

This is why you need to use an operator &

in an expression arre[i]

when you pass it as an argument scanf

.

Note that you do not need to use the operator &

if the argument is already a pointer type. Remember that when you read strings using a conversion specifier %s

, you usually pass an array argument, for example:

char input[81];
scanf( "%s", input );

      

        
        
        
      

    

In this case, the argument is input

implicitly converted from an array from char

expression to a pointer to char

expression, and the expression value is the address of the first element in the array. In most cases, an array expression will "decay" into a pointer expression. As a beginner, this bites you several times.