Thread: structure pass by reference

Hello, I read this code is erroneous, which is related to the pass-by-reference issue. It seems to me each line of code is correct in syntax, and it compiles without any error/warning, but run with segmentation fault. I really do not know why.
Can anybody elaborate the wrong part? Thanks a lot!

Code:

#include <stdio.h>
#include <stdlib.h>

struct node{
int data;
};

void addnode(struct node *x)
{
x = (struct node* )malloc(sizeof(struct node));
x->data = 9;
}

int main( )
{
struct node *N = NULL;
addnode(N);
printf("The value inside the struct = %d\n", N->data);
return 0;
}

addnode is not modifying N in main. To do that you need to pass N's address, receive it as a pointer to a pointer in addnode, and dereference it there to set it in main.

Also check that malloc has succeeded before attempting to use the memory, don't cast malloc, and be sure you free any memory you allocate.

Your code should have indentation, as well.

Code:

#include <stdio.h>
#include <stdlib.h>
 
struct node{
    int data;
};
 
void addnode(struct node **x) {
    *x = malloc(sizeof(struct node));
    if (*x == NULL) { /* handle malloc error */ }
    (*x)->data = 9;
}
 
int main( ) {
    struct node *N = NULL;
    addnode(&N);
    printf("The value inside the struct = %d\n", N->data);
    return 0;
}

The address of a variable is a pointer to whatever type that variable is. If the variable itself is already a pointer, then it's address will be a pointer to a pointer.

Code:

// Given
struct node **x;
//   x is a struct node **    i.e., it's a pointer to a pointer to a struct node
//  *x is a struct node *     i,e., it's a pointer to a struct node
// **x is a struct node       i.e., it's a struct node

Thanks for your explanation on reading the expression "struct node **x".
Something important is missing in my understanding, and I am not sure how to ask my question....
Can I ask in another way: What is the memory manipulation for the correct code when addnote(struct node **x) is called with addnote(&N)?

Code:

addnote(struct node **x); // prototype, the parameter is a pointer-to-pointer of struct node;
addnode(&N); //calling-by-reference, &N is the address of a struct node N;

What I can't understand is: how *x (not **x ) matches &N from memory point of view.
Thanks a lot!

Originally Posted by Yifangt

Code:

addnode(&N); //calling-by-reference, &N is the address of a struct node N;

Thanks a lot!

It isn't, though. You declared N as a pointer,

Code:

struct node *N = NULL;

so that &N is the address of the address of an unnamed struct node.

It isn't, though. You declared N as a pointer,
struct node *N = NULL;
so that &N is the address of the address of an unnamed struct node

Oh?!
Maybe that's the part I missed! Could you please break it down in more detail? I am struggling with pointer-to-pointer. Thanks!

A variable is a named location in memory. That location is where it's value is stored.

A pointer is simply a variable whose value is an address, i.e., it's value is the location of other data.

Dereferencing a pointer causes the pointer's value, an address, to be used to access another location.

A "double pointer" is nothing special at all. It's simply a pointer whose value is the address of another pointer.

Run and study the output of this program. (The (void*) casts are necessary for the proper use of the %p format spec, which prints an address.)

Code:

#include <stdio.h>

void g(int **ppx) {
    printf("    g: ppx (%p) = %p   *ppx = %p   **ppx = %d\n",
           (void*)&ppx, (void*)ppx, (void*)*ppx, **ppx);
    ++**ppx;
    printf("    g: ppx (%p) = %p   *ppx = %p   **ppx = %d\n",
           (void*)&ppx, (void*)ppx, (void*)*ppx, **ppx);
}

void f(int *px) {
    printf("  f:    px (%p) = %p   *px = %d\n",
           (void*)&px, (void*)px, *px);
    ++*px;
    g(&px);
    ++*px;
    printf("  f:    px (%p) = %p   *px = %d\n",
           (void*)&px, (void*)px, *px);
}

int main(void) {
    int x = 1;
    printf("main:    x (%p) = %d\n", (void*)&x, x);
    ++x;
    f(&x);
    ++x;
    printf("main:    x (%p) = %d\n", (void*)&x, x);
    return 0;
}

Possible output:

Code:

main:    x (0x7fff4f8f407c) = 1
  f:    px (0x7fff4f8f4058) = 0x7fff4f8f407c   *px = 2
    g: ppx (0x7fff4f8f4038) = 0x7fff4f8f4058   *ppx = 0x7fff4f8f407c   **ppx = 3
    g: ppx (0x7fff4f8f4038) = 0x7fff4f8f4058   *ppx = 0x7fff4f8f407c   **ppx = 4
  f:    px (0x7fff4f8f4058) = 0x7fff4f8f407c   *px = 5
main:    x (0x7fff4f8f407c) = 6

That helps a lot.
Incidentally, the compiler warnings, telling me the type expected by the escape and the type of what I pass to printf() when I don't use the (void*) casts, also helped shed some light on the subject.

This is becoming way too much work, so this is my last post.

Your code is confused. In main you malloc something for N (although you do it incorrectly, for some reason, but let's pretend you wrote sizeof(struct node)) and then you call addnode_e1 with N, essentially passing the new node you allocated to that function. Then that function mallocs a different chunk of memory to its x parameter, throwing away the passed-in address, sticks some data into that node and then returns, leaking that new chunk of memory. addnode_e2 does better in that it doesn't throw the passed-in address away or leak memory but instead assigns the node malloc'ed in main some data, but why is main malloc'ing the struct in the first place?

Instead of asking these abstract questions, you should say what you're actually trying to do so someone can help you in a more constructive way. For instance, I might write your function like this (if I'm interpreting your purpose correctly).

Code:

struct node *newnode(int data) {  // better name
    struct node *x = malloc(sizeof(*x));
    assert(x);  // the poor man's error handler; only for debugging
    x->data = data;
    return x;
}

/// and call it like this
struct node *N = newnode(91);