1

我的问题是关于以下代码。 

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

因此，代码按原样完美运行。它将每个值正确地插入到 BST 中，并且遍历函数将正确地遍历树。但是，当我最初声明 t 为 BST（例如第 27 行）时，如果我还将 t 指定为 NULL（例如 BST * t = NULL），则插入不再起作用。但是，如果我随后为第一次插入重新分配 t（例如 t = bst_insert(t, 5)），那么一切都会再次起作用。这有什么特别的原因吗？

其次，我如何知道何时需要将指针传递给指向结构的指针？如果我想更改int i指向的值，那么我需要传递&i给一个函数，对吗？但是，如果我想更改 中的值struct node n，那么为什么我需要将 a 传递**node给函数，而不仅仅是 a *node？

非常感谢你看一看。

4

3 回答 3

5

在 C 中，一切都是按值传递的，对此也不例外。

您可以通过传递指针并在函数中取消引用它来模拟传递引用，但这是真正传递引用的差表亲。

底线是，如果要更改传递给函数的任何内容，则必须提供其指针以进行解引用，并且对于更改指针本身而言，这意味着传递指针的指针。注意：

t = modifyAndReturn (t);

不是一回事 - 函数本身不会修改t，它只是返回调用者然后分配给的东西t。

所以，你已经用后一种方式完成了，你可以做这样的事情：

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

使用模拟的传递引用，那将是（使用指针和取消引用）：

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

对于更改指针，如前所述，您需要将指针传递给指针。假设您要更改 char 指针，使其指向下一个字符。你会做这样的事情：

#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++ 实际上通过“修饰符”提供了正确的传递引用，&例如：

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

而且您不必担心函数内的取消引用，任何更改都会立即回显到原始传递的参数。我倒是希望C21能有这个功能，对于不熟悉我们在C中必须忍受的指针体操的人来说，它会省去很多麻烦:-)

顺便说一句，你的代码有一个相当严重的问题。内main，行：

BST * t;

将设置t为不太可能是您想要的任意值。您应该最初将其设置为 NULL 以便bst_insert正确初始化它。

于 2013-08-30T04:32:00.943 回答
1

实际上，您的代码是不正确的，因为您没有t在 main.xml 中分配内存。当您尝试访问指向的值时，您将获得未定义的行为bst_insert_node。正确的方法是将其设置为NULL然后

t = bst_insert(t, 5);
于 2013-08-30T04:33:18.700 回答
0

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

现在，

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

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

tree现在看，上面的语句改变了in指向的位置bst_insert()，而不是tin main()。

因此，当您编写时，您将t = bst_insert(t, 5)显式返回树指向的值以存储在树中，因此代码可以正常工作。

如果不使用返回值，t仍然是NULL.

要么使用这种方式，要么你可以这样做：

bst_insert(BST **tree, int new_val);

而在main()

bst_insert(&t, 5);

现在怎么了！！

现在你将使用*tree = malloc(<some mem>);

因此，您直接分配分配给的内存的基地址：*tree实际上是t它本身。现在您不需要返回 mem 地址。

这与下面的代码相同，写在一个函数中： 

BST **tree;
BST *t;

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

希望你明白我要解释的内容。

于 2013-08-30T04:45:08.407 回答