Pointers as function arguments in C

The difference is simply said in the operations the processor will handle the code with. the value itself is just a adress in both cases, thats true. But as the address gets dereferenced, it's important for the processor and so also for the compiler, to know after dereferencing, what it will be handling with.

If I were to have this code, for example:

int num = 5;
int *ptr = #

What is the difference between the following two functions?:

void func(int **foo);
void func(int *foo);

The first one wants a pointer to a pointer to an int, the second one wants a pointer which directly points to an int.

Where I call the function:

func(&ptr);

As ptr is a pointer to an int, &ptr is an address, compatible with a int **.

The function taking a int * will do somethin different as with int **. The result of the conversation will be completely different, leading to undefined behaviour, maybe causing a crash.

If I pass in func(&ptr) I am effectively passing in a pointer. What difference does it make that the pointer points to another pointer?

               +++++++++++++++++++
adr1 (ptr):    +  adr2           +
               +++++++++++++++++++

               +++++++++++++++++++
adr2 (num):    +  42             +
               +++++++++++++++++++

At adr2, we have an int value, 42.

At adr1, we have the address adr2, having the size of a pointer.

&ptr gives us adr1, ptr, holds the value of &num, which is adr2.

If I use adr1 as an int *, adr2 will be mis-treated as an integer, leading to a (possibly quite big) number.

If I use adr2 as an int **, the first dereference leads to 42, which will be mis-interpreted as an address and possibly make the program crash.

It is more than just optics to have a difference between int * and int **.

I believe the latter will give an incompatibility warning,

... which has a meaning ...

but it seems that the details do not matter so long as you know what you are doing.

Do you?

It seems that perhaps for the sake of readability and understanding the former is a better option (2-star pointer), but from a logical standpoint, what is the difference?

It depends on what the function does with the pointer.

There are two main practical differences:

1. Passing a pointer to a pointer allows the function to modify the contents of that pointer in a way that the caller can see. A classic example is the second argument to strtol(). Following a call to strtol(), the contents of that pointer should point to the first character in the string that was not parsed to compute the long value. If you just passed the pointer to strtol(), then any changes it made would be local, and it would be impossible to inform the caller what the location was. By passing the address of that pointer, strtol() can modify it in a way that the caller can see. It's just like passing the address of any other variable.

2. More fundamentally, the compiler needs to know the type that is being pointed to in order to dereference. For instance, when dereferencing a double *, the compiler will interpret (on an implementation where double consumes 8 bytes) the 8 bytes starting at the memory location as the value of the double. But, on a 32 bit implementation, when dereferencing a double **, the compiler will interpret the 4 bytes starting at that location as the address of another double. When dereferencing a pointer, the type being pointed to is the only information the compiler has about how to interpret the data at that address, so knowing the exact type is critical, and this is why it would be an error to think "they're all just pointers, so what's the difference"?

Generally the difference indicates that the function will be assigning to the pointer, and that this assignment should not just be local to the function. For example (and keep in mind these examples are for the purpose of examining the nature of foo and not complete functions, any more than the code in your original post is supposed to be real working code):

void func1 (int *foo) {
    foo = malloc (sizeof (int));
}

int a = 5;
func1 (&a);

Is similar to

void func2 (int foo) {
    foo = 12;
}

int b = 5;
func2 (b);

In the sense that foo may equal 12 in func2(), but when func2() returns, b will still equal 5. In func1(), foo points to a new int, but a is still a when func1() returns.

What if we wanted to change the value of a or b? WRT b, a normal int:

void func3 (int *foo) {
    *foo = 12;
}    

int b = 5;
func2 (&b);

Will work -- notice we needed a pointer to an int. To change the value in a pointer (ie. the address of the int it points to, and not just the value in the int it points to):

void func4 (int **foo) {
    *foo = malloc (sizeof (int));
}

int *a;
foo (&a);

'a' now points to the memory returned by malloc in func4(). The address &a is the address of a, a pointer to an int. An int pointer contains the address of an int. func4() takes the address of an int pointer so that it can put the address of an int into this address, just as func3() takes the address of an int so that it can put a new int value into it.

That's how the different argument styles are used.

It has been a while since this has been asked, but here is my take on this. I am now trying to learn C and pointers are endlessly confusing... So I am taking this time to clarify pointers on pointers, for me at least. Here is how I think about it.
I have taken an example from here:

#include <stdlib.h>
#include <string.h>

int allocstr(int len, char **retptr)
{
    char *p = malloc(len + 1);  /* +1 for \0 */
    if(p == NULL)
        return 0;
    *retptr = p;
    return 1;
}

int main()  
{
    char *string = "Hello, world!";
    char *copystr;
    if(allocstr(strlen(string), &copystr))
        strcpy(copystr, string);
    else    fprintf(stderr, "out of memory\n");
    return 0;
}

I was wondering why allocstr needs a double pointer. If it is a pointer it means that you can pass it and it will be changed after return...
If you do this example, it works fine. But if you change the allocstr to have just *pointer instead of **pointer (and copystr instead of &copystr in main) you get segmentation fault. Why? I put some printfs in the code and it works fine until the line with strcpy. So I am guessing that it did not allocate memory for copystr. Again, why?
Let's go back to what it means to pass by pointer. It means you pass the memory location and you can write directly there the value you want. You can modify the value because you have access to the memory location of your value.
Similarly, when you pass a pointer to a pointer, you pass the memory location of your pointer - in other words, the memory location of your memory location. And now (pointer to pointer) you can change the memory location as you could change the value when you were using just a pointer.
The reason the code works is that you pass the address of a memory location. The function allocstr changes the size of that memory location so it can hold "Hello world!" and it returns a pointer to that memory location.
It's really the same as passing a pointer but instead of a value we have a memory location.

When using linked structures in C, for example, a simple linked list. Consider you have some items in your list and you want to add a new item, one way, easiest let's say, is to insert at the beginning when items order does not matter. So, here is our simple item structure,

typedef struct {
    char *data;    /* item data */
    struct item *next;    /* point to successor */
} item;

And to insert at the beginning,

void insert_item( item **head, char *data) {

    item *new_item;    /* temporary pointer */

    new_item = malloc( sizeof(item) );
    new_item->data = data;

    /* This is how we would set the next item if the parameter was item* head */
    //new_item->next = head;

    /* till this line, nothing useful for passing item** head */
    new_item->next = *head;

    /*
     * Here is where we needed to update the head to point to the newly inserted item at
     * the beginning. which wouldn't be possible if the head parameter was item* head.
     */
    *head = new_item;
}

You can test this like so,

item *head;
head = malloc( sizeof(item) );
head->data = "head item data";

printf("before inserting: %s \n", head->data); //before inserting: head item data

insert_item(&head, "new item data");

printf("after inserting: %s \n", head->data); //after inserting: new item data