C++ 尝试在C+；中使用空指针时不会发生分段错误+；

我定义了两个类：

template<class Datatype>
class Node
{
    public:
        Node()
        {
            next = NULL;
            prev = NULL;
        }
        Node* getNext()
        {
            return next;
        }
        Node* getPrev()
        {
            return prev;
        }
        Datatype* getData()
        {
            return &data;
        }
        void changeNext()
        {
            next = NULL;
        }
        void changeNext(Node& nextNode)
        {
            next = &nextNode;
        }
        void changePrev()
        {
            prev = NULL;
        }
        void changePrev(Node& prevNode)
        {
            prev = &prevNode;
        }
        Node* addNext(Node &);
        Node* addPrev(Node &);
        void nodeDel();
        void addData(Datatype &);
    private:
        Node* next;
        Node* prev;
        Datatype data;
};

template<class Datatype>
class Stack
{
    public:
        Stack() : node()
        {
            ;
        }
        int push(Datatype &);
        Datatype pop();
        Datatype* peek();
    private:
        Node<Datatype> node;
};

---

我尝试打印下一个节点的数据。显然不应该有任何内容，因为该节点不存在，并且我已经证明了

node.getNext（）

返回

0

。奇怪的是，这里没有发生分段错误，它确实有一个输出0x8。我不知道这是怎么发生的。

取消引用空指针是未定义的行为，这实际上意味着任何事情都可能发生，它不一定会崩溃（尽管操作系统可能会为了自身安全而使应用程序崩溃）。这是高度依赖于实现的，并且应用程序中不应该存在此类代码

引用标准

注意：特别是，空引用不能存在于定义良好的 程序，因为创建此类引用的唯一方法是 将其绑定到通过取消引用空指针获得的“对象”， 这会导致未定义的行为。如9.6所述，参考 不能直接绑定到位字段-尾注

---

getData

返回指向成员的指针；因此，它不需要取消对该的引用，只需向其添加一个偏移量即可。这就是为什么即使

this

为空，也不会出现分段错误

---

当然，它仍然是未定义的行为。

const int&

！=<代码>整数&。后者将无法接受文本作为参数。

template <class Datatype>
int Stack<Datatype>::push(Datatype &new_data)
{
    Node<Datatype> *pt_node = new Node<Datatype>;
    if (pt_node == NULL)
        return -1;

    Datatype *pt_data;

    pt_data = (this -> node).getData();
    pt_node -> addData(*pt_data);   
    (this -> node).addData(new_data);

    pt_node -> addNext(this -> node);

    cout << ((node.getNext())) << endl;

    return 0;
}

cout << ((node.getNext()) -> getData()) << endl;