何时将指针传递给结构作为参数，以及何时将指针传递给结构的指针？

Question

My question is in regards to the following code.

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

struct node
{
    int v;
    struct node * left;
    struct node * right;
};

typedef struct node Node;

struct bst
{
    Node * root;
};

typedef struct bst BST;

BST * bst_insert(BST * tree, int newValue);
Node * bst_insert_node(Node * node, int newValue);
void bst_traverseInOrder(BST * tree); 
void bst_traverseInOrderNode(Node * node);

int main(void)
{
    BST * t;

    bst_insert(t, 5);
    bst_insert(t, 8);
    bst_insert(t, 6);
    bst_insert(t, 3);
    bst_insert(t, 12);

    bst_traverseInOrder(t);

    return 0;
}

BST * bst_insert(BST * tree, int newValue)
{
    if (tree == NULL)
    {
        tree = (BST *) malloc(sizeof(BST));
        tree->root = (Node *) malloc(sizeof(Node));
        tree->root->v = newValue;
        tree->root->left = NULL;
        tree->root->right = NULL;

        return tree;
    }

    tree->root = bst_insert_node(tree->root, newValue);
    return tree;
}

Node * bst_insert_node(Node * node, int newValue)
{
    if (node == NULL)
    {
        Node * new = (Node *) malloc(sizeof(Node));
        new->v = newValue;
        new->left = NULL;
        new->right = NULL;
        return new;
    }
    else if (newValue < node->v)
        node->left = bst_insert_node(node->left, newValue);
    else
        node->right = bst_insert_node(node->right, newValue);

    return node;
}

void bst_traverseInOrder(BST * tree)
{
    if (tree == NULL)
        return;
    else
    {
        bst_traverseInOrderNode(tree->root);
        printf("\n");
    }
}

void bst_traverseInOrderNode(Node * node)
{
    if (node == NULL)
        return;
    else
    {
        bst_traverseInOrderNode(node->left);
        printf("%d ", node->v);
        bst_traverseInOrderNode(node->right);
    }
}

So, the code works perfectly as is. It will insert each value into BST correctly, and the traversal function will traverse the tree inorder correctly. However, when I am initially declaring t to be a BST (eg line 27), if I also assign t to be NULL (eg BST * t = NULL), then the insertion does not work anymore. But, if I then reassign t for the first insertion (eg t = bst_insert(t, 5)), then everything works again. Is there a particular reason for this?

Secondly, how do I know when I need to pass a pointer to a pointer to a structure? If I want to change the value that int i points to, then I need to pass &i to a function, correct? But if I want to change the values within struct node n , then why do I need to pass a **node to a function, and not just a *node ?

Thank you so much for taking a look.

Answer 1

In C, everything is passed by value, there is no exception to this.

You can emulate pass-by-reference by passing the pointer and dereferencing it in the function but this is a poor cousin to real pass-by-reference.

The bottom line is, if you want to change anything passed to a function, you have to provide its pointer for dereferencing and, for changing pointers themselves, that means passing the pointer of the pointer. Note that:

t = modifyAndReturn (t);

is not really the same thing - the function itself does not modify t , it simply returns something which the caller then assigns to t .

So, you've done it the latter way, where you can do something like this:

int add42 (int n) { return n + 42; }
:
x = add42 (x);

Using the emulated pass-by-reference, that would be (with pointers and dereferencing):

void add42 (int *n) { *n += 42; }
:
add42 (&x);

For changing pointers, as mentioned earlier, you need to pass the pointer to the pointer. Let's say you want to change a char pointer so that it points to the next character. You would do something like:

#include <stdio.h>

void pointToNextChar (char **pChPtr) {
    *pChPtr += 1;              // advance the pointer being pointed to.
}

int main (void) {
    char plugh[] = "hello";
    char *xyzzy = plugh;
    pointToNextChar (&xyzzy);
    puts (xyzzy);              // outputs "ello".
}

---

C++ actually provides proper pass-by-reference with the & "modifier" such as:

void add42 (int &n) { n += 42; }

and you don't have to then worry about derefencing within the function, any changes are immediately echoed back to the original passed parameter. I rather hope that C21 will have this feature, it will save a lot of trouble for people unfamiliar with the pointer gymnastics we have to endure in C :-)

---

By the way, you have a rather serious problem with that code. Within main , the line:

BST * t;

will set t to an arbitrary value which is unlikely to be what you want. You should set it initially to NULL so that bst_insert correctly initialises it.

Answer 2

Actually your code is incorrect as it is, because you are not allocating memory for t in your main. You will get undefined behavior when you try to access the value pointed in bst_insert_node . The correct way to do it would be to set it to NULL and then

t = bst_insert(t, 5);  

Answer 3

BST *t; // It declares a pointer of type BST
BST *t = NULL; // Declares pointer same way and pointer points to mem location "0"

Now,

bst_insert(t, 5); // Now "tree" pointer inside "bst_insert" definition points to location pointed by "t" ie NULL (in 2nd case above)

tree = malloc(<some memory>); // Allocates some memory and stores its base address inside "tree"

Now see, above statement changes the location pointed by tree in bst_insert() , but not by t in main() .

So when you write t = bst_insert(t, 5) you return the value pointed by tree explicitly to store in tree, So code works fine.

If you do not use the return value, t is still NULL .

Either use this way, or you can do like this:

bst_insert(BST **tree, int new_val);

And in main()

bst_insert(&t, 5);

What happens now!!

Now you will use *tree = malloc(<some mem>);

So you directly assign base address of memory allocated to: *tree which is actually t itself. Now you need not return the mem address.

This is same as code below, written inside one function:

BST **tree;
BST *t;

tree = &t;
*tree = malloc(<some mem>);  // You are allocating memory and storing address
                             // actually at "t"

Hope you understand what I want to explain.