double astrix pointer question..

what this function does?

Double astrix says that the parameter is the pointer which P points at
so the parameters is p->next and num.
They create a node called elt ,they assign it a memory space in a size node
and make it a node pointer.
next they say that elt->next=p->next
elt->value is num
and p->next=elt


I cant imagine what is the structure of the combination of those to marked red lines.
??

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;
}

---

pass by reference anyone? :D

Quote:

---

Originally Posted by transgalactic2

what this function does?

Double astrix says that the parameter is the pointer which P points at
so the parameters is p->next and num.

---

The parameter is a pointer that points to the pointer which points to a Node. The ** means a pointer to a pointer.
So the parameter is p and num.
There is also a pointer which p points at. Lets call it nodePtr. There is also a node in which nodePtr points to. Lets call it node.

You have this:
p -> nodePtr -> node

So:
elt-> next = *p means: elt->next = nodePtr
*p = elt means: nodePtr = elt

Quote:

---

Originally Posted by audinue

pass by reference anyone? :D

---

In C?

What I think you want is

Code:

---

(*p)->next

---

If I understand you correctly.

It basically takes the address of a pointer to which it assign malloced memory. Only a pointer can store an address, so there you go.

I think EVOEx is on the mark if I understand your question. p is a pointer to pointer to a Node while *p is a pointer to a Node object as in

Code:

---

elt->next=(*p)->next
(*p)->next=elt

---

what means Node **p in the signature??

p->next ?(a pointer which points to a pointer)

am i correct?

p isn't the same as p->next if that is what you mean. I answered what p means in post #3.

It is indeed a pointer that point to a pointer. So its value (*p) is a pointer that points to a node. So p points to a pointer which pointer points to a node.

Quote:

---

Originally Posted by transgalactic2

what means Node **p in the signature??

p->next ?(a pointer which points to a pointer)

am i correct?

---

Node** means it is a pointer to a variable of type Node*. It can be no more simple than that.
And the "p->next" syntax just means "(*p).next", and since *p is a Node*, it is illegal.

so **p point to a Node * type variable

what point to what during this function (in every step)

??

Quote:

---

Originally Posted by transgalactic2

so **p point to a Node * type variable

---

No, if p is a Node**, then **p is a Node.

but what is the stucture of **p regarding a linked list system.

I cant imagine what points to what in every step during the running of this function.

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;
}

---

Quote:

---

Originally Posted by transgalactic2

I cant imagine what points to what in every step during the running of this function.

---

What exactly is the part that you cannot understand?

Look, you have to try and explain what the function does. If you cannot fully explain it, at least show some effort by explaining these two lines:

Code:

---

Node *elt;
elt=(Node*)malloc(sizeof(Node));

---

Then try to explain what this line does:

Code:

---

elt->next=*p;

---

I dont know what it does.
I was asked to explain what it does.
i can guess but this doble astrix thing and linked list
i dont know whats happening in the linked list when the double astrix involved.

Code:

---

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

void what1(Node ** p,int num){
  Node *elt;
  elt=(Node*)malloc(sizeof(Node));  //create a node called elt ,assign it some memory
  elt->next=*p;    //from this point i dont know what the effect of the double astrix
  elt->value=num;
  *p=elt;
}

---

Okay, at least you got the first part. Now, what is the type of elt->next? What is the type of *p?

Quote:

---

Originally Posted by transgalactic2

so **p point to a Node * type variable

---

Of course not.
p points to a Node*!
Pointers to pointers are not special!
So dereference your pointer and you get the original Node* variable.
But wait, you can dereference that original variable too, so you get the Node value (or data).

Code:

---

int* x = malloc( sizeof(int) );
*x = 100;
int** y = &x;
printf("%i", **y);
printf("%i", *x);
// y = address of x (pointer to x!)
// *y = x (the address in x!)
// **y == 100 (the value pointed to by x!)
free(*y);
*y = malloc( sizeof(int) );
**y = 200;
printf("%i", **y);
printf("%i", *x);
free(x);

---

How does this code work and what does it print, do you think?

Quote:

---

Originally Posted by laserlight

Okay, at least you got the first part. Now, what is the type of elt->next? What is the type of *p?

---

*p is the value of P

elt->next is type node

Quote:

---

Originally Posted by transgalactic2

*p is the value of P

---

Huh?

Quote:

---

elt->next is type node

---

That is incorrect. Read the source again.

i ment the value of p
*p is the value of variable p

Yes. Yes, it is. But what type is *p?

Node *

I got a linked list i dont know what points to what
??

Well then, if you understand how the p2p works, then you should be able to understand the code. Is there a specific part you fail to understand yet?

In this code
I pointed in a comment.
it all comes down to who is the "next" of who
and i cant undertand it here?

Code:

---

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

void what1(Node ** p,int num){
  Node *elt;
  elt=(Node*)malloc(sizeof(Node));  //create a node called elt ,assign it some memory
  elt->next=*p;    //from this point i dont know what the effect of the double astrix
  elt->value=num;
  *p=elt;
}

---

It assigns *p to it, and what is *p?

*p is of type Node*

but it doesnt tell me who is the next object of who??

Yes, it does. This line says is all:
*p=elt;
Besides, it is a linked list and at a glance, it should be obvious what it does.

if it were p=elt
i would say it puts the address of elt and puts it to p

but its *p?

i could say
i would say it puts the address of elt and puts it to *p

but it meaningless to me
because its a linked list
i cant see what points to what

The key to the linked list is on this line:

Code:

---

elt->next=*p;

---

This says that the node pointed to by elt now has a next pointer that points to the node pointed to by *p. In more graphical terms, this tongue twister is like this:

First, we have two pointers that point to nodes:

Code:

---

*p --> [node #1]
elt --> [node #2]

---

Now, we get elt's next pointer to point to what *p is pointing to:

Code:

---

elt->next --> [node #1]

---

This means that we now have two nodes linked together:

Code:

---

[node #2] --> [node #1]

---

Now, here's the catch. elt points to node #2, but elt itself is a local variable. When the function ends, elt will be destroyed. What to do?

We can choose to return elt, but in this case we choose to make *p point to what elt points to. As such, the caller now has a pointer to node #2.

Quote:

---

Originally Posted by transgalactic2

if it were p=elt
i would say it puts the address of elt and puts it to p

but its *p?

---

That's because they are of the same type, both elt and *p are pointers to type Node that's why they can be assigned.
You can't equate p = elt because they are of different types; p is a pointer to another pointer while elt is a pointer to type Node.

Quote:

---

Originally Posted by transgalactic2

i could say
i would say it puts the address of elt and puts it to *p

but it meaningless to me
because its a linked list
i cant see what points to what

---

perhaps showing the function that calls what1() might clarify things

the link list structure is like that
(data|next)==>(data|next)==>(data|next)==>(data|ne xt) etc..

the is some node called elt its structure is:
(data|next)
if they would say

Code:

---

elt->next=p;

---

so the next of "elt" is node p
(data|next)==>(data|next)
but they say

Code:

---

elt->next=*p;

---

so its
(data|next)==>(data)

??

i need an explanation that explains it in this simple way of schematics:
(data|next)==>(data|next)==>(data|next)==>(data|ne xt) etc..

Quote:

---

Originally Posted by transgalactic2

the link list structure is like that
(data|next)==>(data|next)==>(data|next)==>(data|ne xt) etc..

the is some node called elt its structure is:
(data|next)
if they would say

Code:

---

elt->next=p;

---

so the next of "elt" is node p
(data|next)==>(data|next)
but they say

Code:

---

elt->next=*p;

---

so its
(data|next)==>(data)

??

i need an explanation that explains it in this simple way of schematics:
(data|next)==>(data|next)==>(data|next)==>(data|ne xt) etc..

---

So what part in this post don't you understand?

i dont understand how whould it change the schematics of the linked list if its
*p instead of p
??

Hello! Wake up!
Because it wants to store the address of the Node, not the address of the pointer to points to the Node!

can you please make a schematics explaining this
because things like
"address of the pointer to points to the Node" are very abstract
i cant imagine it.
can you say how would my linked list look like
after this code??

It's not very abstract.

Code:

---

int main()
{
    int* p = malloc( sizeof(int) );
    foo(&p);
}

void foo(int** p)
{
    free(*p);
}

---

First, malloc is called and the address where the allocation was made is stored in p.
Then the address of p (the address of the pointer!) is passed to foo, which then dereferences that pointer-to-pointer-to-int to get the address stored in p in main, and frees it.

Do you see the connection here?
p in foo is the address of the pointer to the int.

i understand every thing till this part
"which then dereferences that pointer-to-pointer-to-int to get the address stored in p in main, and frees it."

whats dereferces?? (i know that there is no reference in C?)
and i dont know what that means "pointer-to-pointer-to-int to get the address stored in p in main"
can you tell that in simpler words?

Dereference is the process called when you put the * before a pointer.
int* p;
*p = 5; // Dereferences p

>>pointer-to-pointer-to-int
int** basically. It is a pointer, which contains the address of another pointer (thus points to that pointer), and that pointer contains the address of the allocated int, it points to the int:

Code:

---

Pointer1:
    -> points to Pointer2
        -> Pointer2:
            -> points to allocated int

---

>>to get the address stored in p in main
Basically, what that means is that we get the value stored inside the pointer named p, which is defined inside main.

Code:

---

*p = 5; // Dereferences p

---

so derefences means that you put a value in the address of p
correct?
and int** means to use the next pointer of the linked list.

and in this part

Code:

---

foo(&p);

---

you take a number only a number and put it as a parameter of a function
its like saying "use 5 as a pointer"
its just a number
you need to put there a name of a pointer
??

Quote:

---

Originally Posted by transgalactic2

so derefences means that you put a value in the address of p
correct?

---

No, to dereference a pointer is to get what the pointer points to. In the example you get what the pointer points to and assign the value 5 to it.

Quote:

---

Originally Posted by transgalactic2

you take a number only a number and put it as a parameter of a function
its like saying "use 5 as a pointer"

---

No, you take the address of the object, and pass it to the function named foo as an argument.

what we do with this passed address?
where does it go??

Quote:

---

Originally Posted by transgalactic2

what we do with this passed address?
where does it go??

---

It is copied to the function's argument, which is a pointer. After all, a pointer contains an address.

No, no, no. Are you living under a rock?
Have you really no book or do you lack so much understanding of the language?

Quote:

---

Originally Posted by transgalactic2

Code:

---

*p = 5; // Dereferences p

---

so derefences means that you put a value in the address of p
correct?

---

No, no, no.
Dereferencing means getting the value the pointer points at.
So the "*p" part is described as "dereference the pointer p."
Assigning a value is a separate step. Naturally, to assign a value where the pointer points, you must first dereference the pointer.

Look at it this way:
Every variable in a program has to be stored somewhere. So it is stored in memory. And to be able to access things in memory, everything must have an address.
Variables are automatically handled by the compiler, so you can set and get a value from them without trouble. It's transparent.
You can also figure out the address where variables are stored in memory. This "value" must be stored in a pointer.
A pointer is also a variable.
If you assign something to a pointer, you assign an address, because that's what pointers store.
You can also dereference a pointer, which basically means, get (or set) that value stored at the address stored inside this pointer.
Does that make sense?

Quote:

---

and int** means to use the next pointer of the linked list.

---

int** means it's a pointer that stores addresses of int* pointers (pointers-to-int).

Quote:

---

and in this part

Code:

---

foo(&p);

---

you take a number only a number and put it as a parameter of a function
its like saying "use 5 as a pointer"
its just a number
you need to put there a name of a pointer
??

---

This part takes the address of the local variable p, whose type is int*, and passes it along to the function foo, which expects the address of an int* variable (thus it takes an int** argument).

Quote:

---

Originally Posted by transgalactic2

what we do with this passed address?

---

How about this then?

Code:

---

int main()
{
    int* p;
    Allocate(&p);
    Destroy(&p);
}

void Allocate(int** p)
{
    *p = malloc( sizeof(int) );
}

void Destroy(int** p)
{
    free(*p);
    *p = NULL;
}

---

If you can understand how that code works and why it needs to take pointer-to-pointers-to-int, then you have solved the mystery of your original code.

PS: Feel free to merge these posts if that is your wish. Yes, I'm talking to YOU, Moderators! :p

ok i tried to understand the original code again.

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;
}

---

in the parameter
Node ** p
we get some pointer that is being pointed to by p.
and if we are in the realm of linked list
the only pointer which is being pointed by p is p->next .
*p is a dereferencing command
so when we say

Code:

---

  elt->next=*p;

---

that means put the number which was stored in the address which p pointed to
and put it into elt->next which is *(elt).next=some integer number
but *(elt).next is of a pointer type.
so you say elt->next to point to the address which is that integer number (which was in *p)
correct?

This is how a pointer to a pointer works
http://forums.devshed.com/showpost.p...80&postcount=4

that was really funny :)

i understand how a pointer to a pointer works
i just dont know how to understand it in linked list terms
in a linked list there is only node and in that that node there is 'next' which points to another node

That was not funny. Have no one told you that it is considered really bad to cross-post on several forums?

regarding that code

Code:

---

int main()
{
    int* p;
    Allocate(&p);
    Destroy(&p);
}

void Allocate(int** p)
{
    *p = malloc( sizeof(int) );
}

void Destroy(int** p)
{
    free(*p);
    *p = NULL;
}

---

in a normal malloc form that i am used to
we define a pointer

Code:

---

int *p;

---

and then the malloc put the address of the memory into p

Code:

---

p = malloc( sizeof(int) );

---

but when you say

Code:

---

*p = malloc( sizeof(int) );

---

using the dereferencing thing
it just means that you use the address which malloc provides you
and put it as a value in the address where p points to

so you are not using the returned value by malloc as an address as it should be
you just put it on a shelf as a mere integer on some other address

??

No, you are not correct.
Look again, because we store the address from malloc in a pointer.
But in my functions, I have a pointer to the pointer that the address should be stored in. The whole point of the pointer-to-pointer is to store the address inside the pointer in main.

For comparison, I will write an example using a single int variable.

Code:

---

int main()
{
    int p;
    Allocate(&p);
    Destroy(&p);
}

void Allocate(int* p)
{
    *p = 50;
}

void Destroy(int* p)
{
    *p = 10;
}

---

Now, compare this to the other example. It works in the exact same way, only the variable we pass to the functions is of type int* instead of int (as in here).

so in your program *p does not used as a derefencing
but its an actual pointer

??

In a nutshell you need to understand the difference between a pointer to an object and a pointer to a pointer.

Code:

---

char *cp;  /* this is a pointer to an object of type char */
char **dp; /* this is a pointer to a pointer to an object of type char */

---

Quote:

---

Originally Posted by transgalactic2

so in your program *p does not used as a derefencing
but its an actual pointer

??

---

If I dereference an int**, what do I get?
Remember that the type is int**, because I have a pointer that points to another pointer.

Code:

---

int main()
{
    int* p;
    Allocate(&p);
    Destroy(&p);
}

void Allocate(int** p)
{
    *p = malloc( sizeof(int) );
}

void Destroy(int** p)
{
    free(*p);
    *p = NULL;
}

---

When I dereference p in Allocate (marked by orange color), I get the original pointer p defined in main (marked by red color)!
That is because p is Allocate (orange) contains the address of the pointer p in main (red)!

As you well should be aware of, if I would assign malloc to p instead of *p, I would leak memory, because that p (orange) is local to the function Allocate!
So to store that in a variable in main, I have to pass its address to the function, no? That is the normal C way of doing it. And since the variable is a pointer of type int*, a pointer to that variable than becomes int**.
It's not harder than so!

ok but in a linked list the only pointer to a pointer thing that i recognize is
p->next ==>the next node in the list

if its not that
than what is it?
in any case it has to some expression of a linked list
the pointer to pointer thing doent tell me whats happening in the linked list

Quote:

---

Originally Posted by C_ntua

The parameter is a pointer that points to the pointer which points to a Node. The ** means a pointer to a pointer.
So the parameter is p and num.
There is also a pointer which p points at. Lets call it nodePtr. There is also a node in which nodePtr points to. Lets call it node.

You have this:
p -> nodePtr -> node

So:
elt-> next = *p means: elt->next = nodePtr
*p = elt means: nodePtr = elt

---

ahhhhhhhhhh thanks i think i get it now

Quote:

---

Originally Posted by transgalactic2

ok but in a linked list the only pointer to a pointer thing that i recognize is
p->next ==>the next node in the list

if its not that
than what is it?
in any case it has to some expression of a linked list
the pointer to pointer thing doent tell me whats happening in the linked list

---

correct it's an expression too

Code:

---

node **dp; /* pointer to a pointer to a node */
node *sp; /* pointer to a node */
dp = &sp; /* means that dp points to sp and *dp == sp */

---

based on the above, the statements given below are equivalent

Code:

---

sp->next ==> next node in the linked list
(*dp)->next ==> next node in the linked list

---

go figure ;)

Code:

---

node **dp; /* pointer to a pointer to a node */
node *sp; /* pointer to a node */
dp = &sp; /* means that dp points to sp and *dp == sp */

---

ok by the previous definition that i was given dp -> nodePtr -> node
dp has the address of nodeptr
but after

Code:

---

dp = &sp;

---

dp->sp->node
so
*dp == &sp
not
*dp == sp
??

Quote:

---

Originally Posted by transgalactic2

[code]
ok by the previous definition that i was given dp -> nodePtr -> node
dp has the address of nodeptr
but after

Code:

---

dp = &sp;

---

---

Code:

---

*dp == &sp /* wrong */
*dp == sp /* correct */

---

am i correct regarding this definition
dp->sp->node

??

if it true then
dp has the address of sp which is &sp if you write just st
that would mean dp points to node

i understand that dp points to sp
dp==>sp==>node
what exactly this expression means
*dp == sp

*dp is the derefencing form
so *dp is the address of pointer sp

correct?

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.

Quote:

---

Originally Posted by transgalactic2

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?

---

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

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

Quote:

---

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.

Quote:

---

but its not write

---

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

Quote:

---

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*.

Quote:

---

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.

Quote:

---

Originally Posted by transgalactic2

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

Quote:

---

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.

the pointer p the "head" points to *p which points to a node
correct?

but when we do

Code:

---

*p=elt;

---

p is still the head ,but now p points to elt (the new *p)
correct?

but in this case

Code:

---

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

---

will mean that p will point to elp

because p points to *p so if our new *p is elp
then p points to elp
correct?

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.

i thought that when we define
Node **p;
that means that p points to another pointer (*p) and this (*p) points to a node
where is my mistake?

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.

Quote:

---

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).

Quote:

---

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.

so you agree with me that if we define
Node **p;
then we have two pointers in this definition
in which
p points *p

correct?

Quote:

---

Originally Posted by MK27

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

---

You know the mantra ;)
Post the smallest and simplest compilable program that demonstrates the problem.

Quote:

---

Originally Posted by transgalactic2

so you agree with me that if we define
Node **p;
then we have two pointers in this definition
in which
p points *p

correct?

---

No, there is only one pointer, namely, p. p does not point to *p yet because p is left uninitialised.

I must add, once again, that it is only a VARIABLE. It creates ONE VARIABLE, with a certain type. That is all. It is uninitialized, filled with random garbage just like ANY OTHER VARIABLE.

can you give me an example with function calls of actual addresses to understand Node**p
for every address i could see to what node/pointer it corresponds


because i am really confused you said that
*p does point to a node
but to a pointer node

but when i am saying that p points to *p
you say its wrong

Quote:

---

Originally Posted by laserlight

You know the mantra ;)
Post the smallest and simplest compilable program that demonstrates the problem.

---

Hopefully that will be this:

Code:

---

#include <stdlib.h>

typedef struct _node {
        struct _node *next;
} node;

int main () {
        node *test=malloc(sizeof(node)), **p;
        *p=test;
        return 0;
}

---

gcc -Wall test.c
./a.out
Segmentation fault

Try compiling this code, please.
Compile ALL the code you post before you ask.
Go ahead and do it right now. We can wait.