Bdtjtk

I am given a program and am supposed to predict its output.

I have tried to understand the program step by step and write down the value of the variables at each point in the program, but I am not sure what these operations do:

increment(&i);
increment(&a[i]);

#include<stdio.h> 



void increment(int *ptr){

    ++ *ptr;

} 



int main(){ 

    int a={5,10},i=0; 

    increment(a); 

    increment(&i); 

    increment(&a[i]); 

    increment(a+i);

    printf("nResult:i=%dn",i); 

    printf("a[0]=%dn a[1]= %dn", a[0], a[1]);

    return 0 ;

}

The solution is:

Result: i = 1 

a[0] = 6

a[1] = 12

Could you help me understand how I can derive the solution?
Thank you!

but I am not sure what these operations do:

increment(&i); passes the address of i variable to your increment function. That function dereferences the pointer and increments the pointed-to value, which is essentially equivalent to i++.

increment(&a[i]) does the same, but now it passes the address of the i-th element of a. Since i was incremented to 1 before, it is equivalent to a[1]++.

The function increment(int *ptr) expects a pointer to an int, i.e. an address.

Since the variable i is of type int you have to pass its address by using the address-of operator & as in: increment(&i)

a[i] is equal to *(a+i) - i.e. you access the address of the array element at a+i and dereference it in order to get the value of that array element at position i.

Same reason as in the first case, increment expects a pointer and therefore you have to pass an address as in: increment(&a[i]);

Okay here's a step by step explanation in inline comments. Hope it helps. You may need to scroll horizontally to read the full comment.

#include<stdio.h> 

// This function takes a pointer to int and increments the pointed value

void increment(int *ptr){++ *ptr;}      



int main(){ 

    int a={5,10},i=0; // It doesn't look so but here, a is a pointer to int

    increment(a);       // increments the first value pointed by a (a[0]) so now a is [6,10]

    increment(&i);      // increments i, now i = 1

    increment(&a[i]);   // increments a[1], now a = [6,11]

    increment(a+i);     // since i = 1, increments the value right after the one pointed by a so again, a[1], now a = [6,12]

    printf("nResult:i=%dn",i);        

    printf("a[0]=%dn" "a[1]= %dn");

    return 0 ;

}

Let's start with some background information.

First, the expression ++i evaluates to the current value of i plus 1 - as a side effect, the value stored in i is incremented. As a standalone expression, it's roughly equivalent to i = i + 1.

Secondly, except when it is the operand of the sizeof or unary & operators, an expression of type "N-element array of T" (T [N]) will be converted ("decay") to an expression of type "pointer to T" (T *), and the value of the expression will be the address of the first element of the array.

Finally, the expression a[i] is defined as *(a + i) - given a starting address a, offset i elements (not bytes!) from that address and dereference the result. This means that the expression a + i is equivalent to the expression &a[i].

Let's see how this applies to your code:

In the increment function, the line

++ *ptr;

adds 1 to the thing that ptr points to.

When you call increment(a), the expression a has type "2-element array of int". Since a is not the operand of the sizeof or unary & operators, this expression "decays" to type "pointer to int" (int *), and the value of the expression is the address of the first element of a. IOW, it's exactly the same as if you had written increment(&a[0]). Therefore, in the increment function, the following are true:

 ptr == &a[0]

*ptr ==  a[0]

Thus, the expression ++ *ptr is equivalent to the expression ++ a[0]. After this call, a[0] is now 6.

When you call increment(&i), ptr now points to i:

 ptr == &i

*ptr ==  i

so ++ *ptr is equivalent to the expression ++ i, so you're adding 1 to i.

When you call increment(a[i]), i is equal to 1, so this is equivalent to calling increment(a[1]). After this call, a[1] is equal to 11.

And finally, increment(a+i) is equivalent to increment(&a[i]), which is equivalent to increment(&a[1]), and after this call a[1] is equal to 12.