0

我的问题与以下代码有关（请注意，我在此处询问了有关代码不同区域的相关问题）：

#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 = NULL;

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

特别是，似乎我必须重新分配t到bst-insert(t, 5)inmain才能实际修改t自身，因为 bst_insert 不采用 aBST *引用，而只采用值（例如，它永远不能真正改变 aBST *本身）。然而，稍后，当 BST 被创建时，我可以简单地声明bst_insert(t, 8)，这将改变t自己（例如 change t->root->left），即使它没有t通过引用作为参数接收。有人可以向我解释这里的区别吗？非常感谢！

4

2 回答 2

3

“...因为 bst_insert 不通过引用获取 BST *，而仅通过值..”您使用了错误的术语，这可能是由于对以下概念的理解不清楚。

C 没有按引用传递：函数的每个参数都按值传递。按值传递意味着当进行函数调用时，参数被复制并且函数的相应参数将获得该副本。因此，在函数内部，您使用参数的副本。

相反，某些语言（尤其是 C++，但不是 C）可能会通过引用传递参数。这意味着函数中的相应参数成为参数的别名，即它可以用作同一对象的替代名称。在这种情况下，您在函数内部使用别名对对象进行的任何修改都会影响函数“外部”的参数。

在 C 语言中，您可以使用指针作为函数参数更接近按引用传递的行为。如果你传递一个指针值（即一个对象地址），你可以在函数内部使用它来间接改变指针所指向的对象。

有人将此称为“技巧” pass-by-pointer（或call-by-pointer），但 IMO 这个术语可能会误导不了解实际底层机制的初学者。事实上，它根本不是新机制，它只是应用于指针值的按值传递！事实上，您对指针本身（与指向的对象相反）所做的任何更改都将是本地的，即不会影响您在调用中传递的实际指针。

于 2013-08-30T06:38:18.427 回答
2

不同之处在于，在第一次调用（when tis NULL）中，函数bst_insert正在更改指针t本身（它正在为twith分配一个新值malloc）。在接下来的调用中，t它本身没有被修改，只有它指向的内容。例如，改变t->root意味着改变由 指向的内容t，而不是改变t它本身（它指向的地址）。

于 2013-08-30T05:10:50.627 回答