将空赋给双指针

Question

I need to understand why assigning void* to int** will work, but when printing the value of int** , it will not work. Here's the code:

int k = 3;
int *l = &k;
void *a = l; 
int **c = a; // if I assign, &a, the below line work, but get warning: incompatible
             // pointer type.
printf("%d", **c); // Code break;

But this line

printf("%d", *c); // will work, but get warning "%d expect int but of type int *".

Update: I saw this type of code in OOC book where author do this:

struct Class {
   size_t size;
   int (*differ)(const void *self, const void *b);
   ..... Some more code ....

};

int differ(const void *self, const void *b) {
  // Note this line
  const struct Class **cp = self;
  assert(self && *cp && (*cp)->differ);
  return (*cp)->differ(self, b);
}

Answer 1

You have this situation:

+---+
| l | --\
+---+    \     +---+
          >--> | k |
+---+    /     +---+
| a | --/
+---+

Ie both l and a points directly to k .

When you then do

int **c = a;

you make c point to what a is pointing to as well (ie it's the same as doing int **c = &k ), but you declare c to be a pointer to pointer to an int , but make it point directly to an int . That means using single dereference ( *c ) you get the value of k , and when you you use double dereference ( **c ) you use the value of k as a pointer (which it isn't).

I assume what you really want is this situation:

+---+     +---+     +---+
| a | --> | l | --> | k |
+---+     +---+     +---+

which you will get by doing

void *a = &l;

Then using c as a pointer to pointer will work because then a is a pointer to a pointer.

---

If you continue with the first scenario, where you have

int   k;
int  *l = &k;
void *a = l;

and then do

int **c = (int **) &a;  // The typecast is needed

Then you have the following situation:

+---+
          | l | --\
          +---+    \     +---+
                    >--> | k |
+---+     +---+    /     +---+
| c | --> | a | --/
+---+     +---+

This will work because then c really is a pointer to a pointer to something.

Answer 2

This is why you have to be careful with void* pointers. You can assign any pointer to them, and you can assign them to any other pointer. Even if it doesn't make sense (like your example).

When you assign int **c = a , you've committed an error, that I think you're already aware of. You've changed levels of indirection ( a came from an int* , but you're assigning it to an int** ), but didn't take another address-of ( & ).

Your program fails for the same reason that, if you eliminated the void* a , and instead tried this, it would fail.

int k = 3;
int *l = &k;
int **c = l;    // Error - wrong level of indirection.

This is low-level C. Just because the compiler lets you do something doesn't mean it will work.

The solution to this question is: Don't do it .