Thread: double astrix pointer question..

Let's fill these expressions and things with values.
node = 10
sp = 20
dp = 30

So, that means:
dp = address of sp (30)
*dp = value of sp [address of node] (20)
**dp = value of node (10)

Code:

typedef struct node {
    int value;
    struct node *next;
}Node;

void what1(Node ** p,int num){
   Node *elt;
   elt=(Node*)malloc(sizeof(Node));
   elt->next=*p;
   elt->value=num;
   *p=elt;
}

so what this function does is building some pointer to node variable called elt.
then elt->next get to be pointed at the pointer which "p" points to
elt->value gets the "num"
and then the pointer which "p" pointed to ,points at the elt pointer??
but its not write
because by your definition p pints to a pointer
but *p must point a node
but it points at a pointer
so by this operation

Code:

*p=elt;

they transform p from being pointer to pointer to node
into pointer to pointer to pointer to node

correct?

Half of the time, I don't even know what you're talking about...

Code:

typedef struct node
{
    int value;
    struct node* next;
} Node;

int main()
{
    Node* pFirstNode = malloc( sizeof(Node) );
    pFirstNode->value = 0;
    pFirstNode->next = NULL;
    what1(&pFirstNode, 10);
}

void what1(Node** p, int num)
{
   Node* elt; // Define a new empty pointer
   elt = (Node*)malloc( sizeof(Node) ); // Allocate a new node, store in elt
   elt->next = *p; // Put the address stored in pFirstNode in main inside elt->next
   elt->value = num; // Store num in elt->value
   *p = elt; // Assign the address of the new node to pFirstNode in main.
}

elt = new node
p -> pFirstNode -> Node

Freeing left out for simplicity.
Now let's see you figure out how or why.

As I said, half of the time, I don't know what you are writing.

Originally Posted by transgalactic2

so what this function does is building some pointer to node variable called elt.
then elt->next get to be pointed at the pointer which "p" points to
elt->value gets the "num"
and then the pointer which "p" pointed to ,points at the elt pointer??

That part is correct from what I can assume, if I understand correctly.

but its not write

The word is "right", not "write".
And yes, it is right.

because by your definition p pints to a pointer
but *p must point a node

p points to a pointer, yes, and no, *p must not point to a node. p points to a pointer, Node*, so *p is a Node*.

but it points at a pointer
so by this operation

Code:

*p=elt;

they transform p from being pointer to pointer to node
into pointer to pointer to pointer to node

correct?

Absolutely not. What makes you think that?
"p" is not transformed at all.
What p is pointing to is assigned the address of the new node which elt points at.

Have you actually considered that C may not be for you?
You seem to have an awful lot of problems, never able to do it right, even the simplest of things.

Originally Posted by transgalactic2

can you tell me in what point i got this theory wrong

but its not write
because by your definition p pints to a pointer
but *p must point a node
but it points at a pointer
so by this operation
Code:

*p=elt;

they transform p from being pointer to pointer to node
into pointer to pointer to pointer to node

The heart of your misunderstanding is in red. By assigning a pointer the same value as another pointer, they point to the same place:

Code:

node *p, *elt=malloc(sizeof(node));
p=elt;
elt->next=p;

Would be a circular linked list with two members. You can swap pointers around as much as you like:

Code:

elt=p;
p->next=elt->next;
elt->next=p->next;
p=elt;
p=p->next;

They all still point to a node, not to a pointer to a pointer to a pointer to a node or something.

No, that results in undefined behaviour. p does not point to anything, so *p is a pointer that does not exist. Other than that, yes, p points to elt.

Okay, you are wanting to use pointers to pointers, so I guess in this case:

Code:

node **p, *elt;
*p=elt;

p is a pointer to a pointer, however it cannot be a pointer to a node, so you cannot access the members of a node using *p (there is no *p->next). However, if you cast it as a character block, (char*)*p you can accesses the contents of the node pointed to by the pointer *p points to byte by byte.

I haven't seen pointers to pointers performing a useful purpose in linked lists tho, so you are kind of pouring pickled pepper lemon juice in your milk here. I could be wrong.

Originally Posted by MK27

p is a pointer to a pointer, however it cannot be a pointer to a node, so you cannot access the members of a node using *p (there is no *p->next).

It is correct to say that since p is a pointer to a pointer it cannot be a pointer to a node, since a node is not a pointer. However, it is not correct to say that one cannot access the members of a node via p, since *p is a pointer to a node, hence (*p)->next is valid (assuming that p actually points to an existing pointer to a node, rather than to nothing as is the case at the moment).

Originally Posted by laserlight

(*p)->next is valid (assuming that p actually points to an existing pointer to a node, rather than to nothing as is the case at the moment).

Okay. Maybe the reason I haven't tried that is because this:

Code:

node *test=malloc(sizeof(node)), **p;
*p=test;

Actually causes a segfault on my system. I'm guessing that transgalactic2 is not actually trying any code to see what it does before (s)he asks what it could mean.

I can do this:

Code:

node *test=malloc(sizeof(node)), **p;
p=&test;

which I imagine is not the same thing, but then (*p)->next causes a segfault.