Comparing between a double pointer ** and a constant works only if I one *

Question

#include <stdio.h>


struct mychar {
    char value;
    struct mychar *nextPtr;
};

typedef struct mychar Mychar;


void insert(Mychar **, char );

int main(){
    Mychar *startPtr = NULL;    // line 13

    insert(&startPtr, 'b');

}

void insert(Mychar **sPtr, char myvalue){

    if (**sPtr == NULL){    // if I put double ** it doesn't work. it works only with one *
        // do stuff
    }

I got this error:

liste_collegate.c:13:13: error: invalid operands to binary expression ('Mychar' (aka 'struct mychar') and 'void *')
        if (**sPtr == NULL){
            ~~~~~~ ^  ~~~~

I really don't get why if I initialize startPtr at line 13 with Mychar *startPtr = NULL; and then I pass the address of that pointer to insertfunction, I can't get the value if I put two ** but it works only if I put only one *.

Shouldn't I dereferenciate two times in order to reach value NULL? I mean, if I am passing an address of a pointer to a function, that function will need to derefernciate one time to reach the value of the address inside the first pointer, and then another time to reach the real value in that address...

Why doesn't it work?

Of course I know that there must be something wrong, just I don't know why.

Answer 1

"Shouldn't I dereference two times in order to reach value NULL??"

No.

It is because NULL is a macro for assigning or comparing a pointer to a null pointer (a pointer which points to no (valid) memory); It is used for pointers only, not it´s referenced objects - the object they point to (unless the referenced object is also a pointer and you want to check if for NULL, but that´s not the case here).

---

**sPtr is a pointer to pointer to type Mychar. If you dereference sPtr ( means *sPtr) you access the pointer it is pointing to (actually startPtr in main), which is correct for checking startPtr for NULL.

If you use if (**sPtr == NULL) you attempt to dereference startPtr - a NULL pointer - itself, which is invalid and attempt to check the object startPtr is pointing to (actually nothing) for NULL, but not startPtr.

Feel free to ask for further clarification.

Answer 2

In main(), you defined startPtr to be a pointer pointing to a location that is of type Mychar. In the above picture, your startPtr is similar to int *p. You passed the address of that startPtr to insert function. That is, you passed something similar to int **pp in the above image.

When you just hit sPtr, you're seeing the value inside that variable, which is something similar to the value contained in **pp in the above image (0x450).

When you say *sPtr, you're dereferencing the value inside sPtr, which is something like the value contained in *p (0x200), which in your case is 3. So, dereferencing once is enough. When you dereference twice, you're dereferencing 3, which may cause segmentation fault if the address 3 is not part of your process.

Answer 3

Did you see the warning and the error when you compile the code:

Mychar *startPtr = 3;    // line 13

This line raises the warning:

warning: initialization makes pointer from integer without a cast [-Wint-conversion]

if (**sPtr == 3)

An this line raises the error:

error: invalid operands to binary == (have ‘Mychar {aka struct mychar}’ and ‘int’)

For the warning, you try to assign the pointer to an integer, maybe you want something like:

Mychar startValue;
startValue.value = 3;
// then initialize the pointer by making it point to address of startValue
Mychar *startPtr = &startValue;

For the error (answer with your update), you try to compare a value with NULL pointer. As the your last question, NULL is use for only pointer, so you can compare the pointer NULL with only another pointer. Maybe you can:

if (*sPtr == NULL) {}
// OR
if (*sPtr == NULL) {}
// But not
if (**sPtr == NULL) {}