C++| BST 引用节点指针与节点指针

Question

假设我有这个 BST 模板：

template <typename T> class Node {
private:
public:
  T data;
  Node *left;
  Node *right;

  Node(T dt) : data{dt}, left{nullptr}, right{nullptr} {}
  ~Node() {
    this->data = 0;
    this->left = nullptr;
    this->right = nullptr;
  }
};

template <typename T> class BST {
private:
  Node<T> *_root;

  _insert();
  _add();
  _printOrder_In(Node<T> *parent, std::ostream& os) {
    if (!parent) return;
    _printOrder_In(parent->left, os);
    os << parent->data << ' ';
    _printOrder_In(parent->right, os);
  }

public:
  BST() : _root{nullptr} {}
  ~BST();
  
  insert();
  add();
  std::ostream& print(std::ostream& os = std::cout) {
    _printOder_In(this->_root, os);
    return os;
  }
};

为什么以下代码在我传递对节点指针的引用时有效，而在传递节点指针时不起作用？

// BST MEMBER FUNCTIONS:
private:
  void _insert(Node<T>* &parent, const T &val) { // works
//void _insert(Node<T>*  parent, const T &val) { // doesn't work, apparently generates nodes indefinitely
    if (!parent)
      parent = new Node<T>{val};
    else {
      if (val < parent->data)
        _insert(parent->left, val);
      else if (val > parent->data)
        _insert(parent->right, val);
      else
        return;
    }
  }

public:
  void insert(const T &val) {
    _insert(this->_root, val);
  }
};

也与此替代方法相反，该方法仅适用于传递的指针：

// BST MEMBER FUNCTIONS:
private:
  void _add(Node<T>* parent, T val) {
    if (parent->data > val) {
      if (!parent->left) {
        parent->left = new Node<T>{val};
      } else {
        _add(parent->left, val);
      }
    } else {
      if (!parent->right) {
        parent->right = new Node<T>{val};
      } else {
        _add(parent->right, val);
      }
    }
  }

public:
  void add(T val) {
    if (this->_root) {
      this->_add(this->_root, val);
    } else {
      this->_root = new Node<T>(val);
    }
  }

---

我知道对点的引用将让我直接访问传递的指针。 但是，我坚持两种方法之间的区别。 在第二种方法中，尽管指针本身没有作为引用传递，但控制流中使用的本地副本仍然有效。

Answer 1

OP 问题是关于call-by-value 与 call-by-reference 。

C 语言（C++ 的“先驱”）专门提供按值调用。 可以通过使用变量的地址而不是变量本身来模拟丢失的按引用调用。 （当然，resp. 函数的参数必须成为指向类型的指针，而不是类型本身。）

因此，指针是按值传递的，但它的值可用于访问函数范围之外的内容，并且修改（在其原始存储中完成）将在该函数返回后继续存在。

当 C++ 从 C 演变而来时，这个原则就被接管了。 但是，C++ 添加了引用调用，就像从其他类似语言（例如 Pascal）中已知的那样。

按值调用与按引用调用的简单演示：

#include <iostream>

void callByValue(int a)
{
  std::cout
    << "callByValue():\n"
    << "  a: " << a << '\n'
    << "  a = 123;\n";
  a = 123;
  std::cout
    << "  a: " << a << '\n';
}

void callByRef(int &a)
{
  std::cout
    << "callByRef():\n"
    << "  a: " << a << '\n'
    << "  a = 123;\n";
  a = 123;
  std::cout
    << "  a: " << a << '\n';
}

int main()
{
  int b = 0;
  std::cout << "b: " << b << '\n';
  callByValue(b);
  std::cout << "b: " << b << '\n';
  callByRef(b);
  std::cout << "b: " << b << '\n';
}

输出：

b: 0
callByValue():
  a: 0
  a = 123;
  a: 123
b: 0
callByRef():
  a: 0
  a = 123;
  a: 123
b: 123

解释：

• 的变化a只在局部作用callByValue()因为a是值传递。 （即参数的副本被传递给函数。）
• a更改会修改callByRef()传递的参数，因为a是通过引用传递的。

十分简单？ 当然。 但是，如果参数类型这是完全相同的int的a是由任何其它类型的置换-例如Node*或甚至Node<T>* 。

我从 OPs 代码中取出相关行：

  void _insert(Node<T>* &parent, const T &val) { // works
    if (!parent)
      parent = new Node<T>{val};

如果参数parent值为nullptr ，则为parent分配新创建的Node<T>的地址。 从而修改通过引用传递的指针（变量）。 因此，在离开函数_insert()后修改仍然存在。

另一种选择：

  void _insert(Node<T>*  parent, const T &val) { // doesn't work, apparently generates nodes indefinitely
    if (!parent)
      parent = new Node<T>{val};

如果参数parent值为nullptr ，则为parent分配新创建的Node<T>的地址。 因此，指针按值传递。 因此，（原始）变量（在调用中使用）没有改变——并且在函数离开时仍然包含nullptr 。

顺便提一句。 据此，创建的Node<T>的地址将丢失。 （它不再存储在任何地方。）然而， Node<T>实例仍然驻留在它们分配的内存中——在进程结束前不可访问——降级为一块浪费的内存。 这是一个如何发生内存泄漏的示例。

请不要将这个事实与指针本身“模仿”传递引用的另一个事实混淆。 指针指向的对象（类型为Node<T> ）的修改（如果它不是nullptr ）将变得持久。

仔细查看_add() ，似乎只有指向对象（类型Node<T> ）被修改，但从未修改指针本身。 因此，按值传递它是完全足够的。

但是为了_insert()的正确工作，对parent本身的修改也必须变得持久。 因此，只有第一个选项才能正常工作。