C++ 指针的引用可以为空吗？

Question

给定以下代码：

template<class S, class T>
class node {
public:
    S key;
    T value;
    node<S, T> *right_node, *left_node, *parent_node, *nearest_right_node, *nearest_left_node;
    int height;

public:
    template<typename, typename> friend
    class avl_tree;

    node() = default;

    node(const S *key, const T *value, node<S, T> *right_node = nullptr, node<S, T> *left_node = nullptr,
         node<S, T> *parent_node = nullptr, node<S, T> *nearest_right_node = nullptr,
         node<S, T> *nearest_left_node = nullptr) : key(*key),
                                                    value(*value),
                                                    right_node(right_node),
                                                    left_node(left_node),
                                                    parent_node(parent_node),
                                                    nearest_right_node(nearest_right_node),
                                                    nearest_left_node(nearest_left_node),
                                                    height(0) {
    }

    ~node() = default;
};

我可以用引用替换 c'tor 中 value 和 key 的指针，并且仍然可以给 key 和 value 一个 nullptr 值吗？ （例如，如果 S 是 int*）？

更新：

int* x;

    void update_x(int &new_x)
    {
        x=new_x;
    }

我可以打电话给update_x(null_ptr)

Answer 1

您的代码中的问题归结为：

void foo(int* x) {
   int y = *x;
}

将nullptr 传递给foo 将导致未定义的行为，因为您不应取消引用nullptr。

使用参考是可能的，但不会改变这一事实：

void bar(int*& x) {
    int y = *x;
}

这是通过引用传递指针。

int a;
int* p = &a;
bar(p);

现在bar 中的x 是对指向a 的指针的引用。但是，您不能将空指针传递给bar，因为bar 正在取消引用该指针。一些恶意代码可以做到这一点：

int* p = nullptr;
bar(p);           // DO NOT DO THIS !!!

然后int y = *x; 将调用未定义的行为。

如果函数期望总是得到一个有效的对象，它应该通过引用来获取它：

void foo_bar(int& x) {
    int y = x;   // no danger, all fine
}

---

引用不能引用任何内容。它们必须被初始化：

int& x; // ERROR !
int y;
int& z = y;  // OK, z refers to y

另一方面，指针并不总是指向有效的指针：

int* p;       // not initialized, no (big) problem
p = nullptr;  // still not pointing to an int
int q;
p = &q;       // now p points to an int

引用不能引用任何内容，这就是为什么当“无”不是有效参数时，您应该更喜欢引用而不是指针。在您的情况下，您始终要求 *value 有效，因此 value 始终必须指向 S 并且您应该使用引用来避免上述问题。

---

关于您的更新：

int* x;

    void update_x(int &new_x)
    {
        x=new_x;
    }

我可以调用 update_x(null_ptr)

没有。你不能。 nullptr 不是 int。对int 的引用始终引用int。

Answer 2

您的node 类有成员S key 和T value，构造函数参数const S *key 和const T *value 分别使用key(*key) 和value(*value) 初始化成员，这将复制 成员的输入值。

如果将nullptr 传递给任一参数，则在取消引用nullptr 时代码具有未定义的行为。

参数根本没有理由是指针。它们应该通过按值传递：

template<class S, class T>
class node {
public:
    S key;
    T value;
    ...

public:
    ...

    node(S key, T value, ...) : key(key), value(value), ... { }
    // or: node(S key, T value, ...) : key(std::move(key)), value(std::move(value)), ... { }

    ...
};

或通过常量引用：

template<class S, class T>
class node {
public:
    S key;
    T value;
    ...

public:
    ...

    node(const S& key, const T& value, ...) : key(key), value(value), ... { }

    ...
};

或通过右值引用：

template<class S, class T>
class node {
public:
    S key;
    T value;
    ...

public:
    ...

    node(S&& key, T&& value, ...) : key(std::move(key)), value(std::move(value)), ... { }

    ...
};

如果S 或T 被定义为指针类型，那么nullptr 可以作为值 传递给key/value 成员，例如：

node<int, type*> *n = new node<int, type*>(1, nullptr);

type t;
node<int, type*> *n = new node<int, type*>(1, &t);

但是如果S和T不是指针类型，就不应该作为指针传入：

type t;
node<int, type> *n = new node<int, type>(1, t);

type t;
node<int, type> *n = new node<int, type>(1, std::move(t));

node<int, type> *n = new node<int, type>(1, type{});