Why is the output of the following program 2 97 and not 2 2?

Question

In the following code why doesn't the address of j gets overwritten in p when we call the foo function?

#include <stdio.h>
        int main()
        {
            int i = 97, *p = &i;
            foo(&i);
            printf("%d ", *p);
        }
        void foo(int *p)
        {
            int j = 2;
            p = &j;
            printf("%d ", *p);
        }

Answer 1

You are printing with foo - which sets p to 2, then you call a print to p, which is still set to 97 in that scope. foo does not set p globally.

Answer 2

Because p in main is another variable than p in the function. Consequently, even if p is changed inside the function, the value of p in main is still the same and still points to 97.

In more details:

    int main()
    {
        int i = 97, *p = &i;  // i is 97 and p points to i
        foo(&i);
        printf("%d ", *p);    // This prints what p points to, i.e. 97
    }
    void foo(int *p)
    {
        int j = 2;   // Here p still points to i in main
        p = &j;      // Now p points to j, i.e. the value 2
        printf("%d ", *p);  // So this prints 2
    }

Just to repeat: The important thing is that p in main and p in foo are two different variables.

If you want the program to print 2 2 you can change the function to:

    void foo(int *p)
    {
        int j = 2;
        *p = j;     // Change this line. This will change i in main
                    // and thereby also the value that p in main points to
        printf("%d ", *p);
    }

Answer 3

Below are the steps:

    int main()
    {
        int  i = 97;
        int* p = &i;        // 1. p points to i, i is 97.
        foo(&i);            // 2. Pass the address of i by value.

        printf("%d ", *p);  // 6. Print the value of i as neither p nor i have not changed inside foo().
    }

    // I've renamed the parameter name from p to q for clarity. q is local to
    // foo() only; changes made to q are only visible within foo().
    void foo(int* q)
    {                      // 3. q contains a copy of i's address.
        int j = 2;
        q     = &j;        // 4. q is set to the address of j. 

        printf("%d ", *q); // 5. Print the value of j.
    }

If you would have done *q = 2 inside foo() you would have changed i's value to 2. That's because q contains the address of i.

Answer 4

The p in main is a different object in memory than the p in foo. Writing to one has no effect on the other. If you want foo to update the value of p in main, then you must pass a pointer to p:

#include <stdio.h>
int main()
{
    int i = 97, *p = &i;
    foo(&p);
    printf("%d ", *p);
}

void foo(int **p)
{
    int j = 2;
    *p = &j;
    printf("%d ", **p);
}

WARNING - doing this will invoke undefined behavior, since p will point to an object that no longer exists - once foo exits, j no longer exists, and p will be an invalid pointer. You may get the output you expect, or you may not.

In order for a function to write to a parameter, you must pass a pointer to that parameter:

void foo( T *ptr )
{
  *ptr = new_value(); // updates the thing ptr points to
}

void bar( void )
{
  T var;              // var is an instance of T
  foo( &var );        // have foo update the value of var
}

This is true for any non-array type T, including pointer types. If we replace T with the pointer type P *, we get

void foo( P * *ptr )
{
  *ptr = new_value(); // updates the thing ptr points to
}

void bar( void )
{
  P * var;            // var is an instance of P *
  foo( &var );        // have foo update the value of var
}

The semantics are exactly the same - the only thing that's changed is that var starts out as a pointer type.

Things get weird with array types, which we're not going to go into quite yet.