Why is the output of the code 8,5,5 and not 8,8,5?

#include<stdio.h>
#include<stdlib.h>

void f(int x, int* y, int **z)
{
    *z = malloc(sizeof(int));
    **z = 4;
    **z += 1;
    x += 2;
    *y += 3;
}

int main()
{
    int x = 5;
    int *y = &x;
    int **z = &y;
    f(x, y, z);
    printf("%d, %d, %d", x, *y, **z);
    return 0;
}

So,here is my take on the problem-

first in the main z and y point to x which is 5.When function is called new variables x,y,z are created of their types and y,z in the function beginning eventually point to the x in the main.Now z is made to point to a int space in heap.Here the value of z pointing to the heap becomes 5.then x in the function becomes 7 and in the last line of function *y+=3 makes an increment to x value in main (making it 8).

now the flow of control returns to main

and x should be x in main that is 8 y should be 8 since it points to x in main. and z should be 5 since it points in the heap.

where did I go wrong?

f's z points to main's y, not f's y. main's y and f's y are distinct variables, even if they have the same value for a time. Changing one doesn't change the other.

I'm going to illustrate what is happening as we step through the program line by line (more or less). But first, I'm going to rename f's parameters to avoid confusion.

void f(int a, int* b, int **c)
{
    *c = malloc(sizeof(int));
    **c = 4;
    **c += 1;
    a += 2;
    *b += 3;
}

1. After

   int x = 5;
   int *y = &x;
   int **z = &y;
   

   we have

   int **z @ 3000     int *y @ 2000      int x @ 1000
   +-----------+      +-----------+      +-----------+
   | 2000   --------->| 1000   --------->|         5 |
   +-----------+      +-----------+      +-----------+
   

   (All addresses invented. The exact numbers are irrelevant.)

2. We call f. This copies main's x, y and z into f's a, b and c.

   int **z @ 3000     int *y @ 2000      int x @ 1000
   +-----------+      +-----------+      +-----------+
   | 2000   ------+-->| 1000   ------+-->|         5 |
   +-----------+  |   +-----------+  |   +-----------+
        ||        |        ||        |        ||
        ||        |        ||        |        ||
       copy       |       copy       |       copy
        ||        |        ||        |        ||
        VV        |        VV        |        VV
   int **c @ 6000 |   int *b @ 5000  |   int a @ 4000
   +-----------+  |   +-----------+  |   +-----------+
   | 2000   ------+   | 1000   ------+   |         5 |
   +-----------+      +-----------+      +-----------+
   

3. After

   *c = malloc(sizeof(int));
   

   we have

                                         int @ 7000
                                         +-----------+
                                    +--->| ????????? |
                                    |    +-----------+
                                    |
   int **z @ 3000     int *y @ 2000 |    int x @ 1000
   +-----------+      +-----------+ |    +-----------+
   | 2000   ------+-->| 7000   -----+ +->|         5 |
   +-----------+  |   +-----------+   |  +-----------+
                  |                   |
   int **c @ 6000 |   int *b @ 5000   |  int a @ 4000
   +-----------+  |   +-----------+   |  +-----------+
   | 2000   ------+   | 1000   -------+  |         5 |
   +-----------+      +-----------+      +-----------+
   

   Remember that c points to main's y.

4. After

   **c = 4;
   **c += 1;
   a += 2;
   *b += 3;
   

   we have

                                         int @ 7000
                                         +-----------+
                                    +--->|         5 | (4+1)
                                    |    +-----------+
                                    |
   int **z @ 3000     int *y @ 2000 |    int x @ 1000
   +-----------+      +-----------+ |    +-----------+
   | 2000   ------+-->| 7000   -----+ +->|         8 | (5+3)
   +-----------+  |   +-----------+   |  +-----------+
                  |                   |
   int **c @ 6000 |   int *b @ 5000   |  int a @ 4000
   +-----------+  |   +-----------+   |  +-----------+
   | 2000   ------+   | 1000   -------+  |         7 | (5+2)
   +-----------+      +-----------+      +-----------+
   

5. Then, back in main, we print x, *y (the anon block), and **z (again, the anon block via *y).

First off, the x += 2 in f means absolutely nothing because of pass-by-value semantics and it's never used again, so let's get rid of it.

void f(int x, int* y, int **z)
{
    *z = malloc(sizeof(int));
    **z = 4;
    **z += 1;
    *y += 3;
}

z is a pointer to y. When we dereference it and assign we're assigning to y in main. That y now points to some block of memory the right size for an int. The y that's our function argument is unchanged by this.

We now assign 4 to that chunk of memory, and then we increment it by 1. The y in main is now 5.

The y function argument still points to x in main, so when we dereference it and add 3, it's now 8.

The z in main still points to y, so that's 5 as well.

Thus 8, 5, 5 is printed.

Pass-by-value semantics in C are the real kicker here. I wonder if this would be easier to understand if we were looking at:

#include <stdio.h>
#include <stdlib.h>

void f(int a, int* b, int **c)
{
    *c = malloc(sizeof(int));
    **c = 4;
    **c += 1;
    a += 2;
    *b += 3;
}

int main()
{
    int x = 5;
    int *y = &x;
    int **z = &y;
    f(x, y, z);
    printf("%d, %d, %d", x, *y, **z);
    return 0;
}