使用指针表示堆栈

Representing a stack using pointers

本文关键字：堆栈 表示 指针      更新时间：2023-10-16

我似乎不懂C++中的指针，我希望我的例子能帮助你指导我我有以下代码：

   #include "stdafx.h"
   #include <iostream>
   using namespace std;

头等舱：

    class Node
    {
    private:
        int value;
        Node *next;
    public:
        Node()
       {
            value = 0;
       }
       ~Node()
       {
       }
       void setValue(int x)
       {
           value = x;
        }
        int getValue()
        {
           return value;
        }
        void setNext(Node x)
        {
            next = &x;
        }
        Node getNext()
        {
            return *next;
        }
     };

二等：

    class Stack
    {
    private:
       Node *top;
    public:
        Stack()
        {
           top = NULL;
        }
        ~Stack()
        {
        }
        Node pop()
        {
            Node *temp = top;
            top = &top->getNext();
            return *temp;
        }
        void push(Node &x)
        {
            x.setNext(getTop());
            setTop(x);
        }
        Node getTop()
        {
            return *top;
        }
        void setTop(Node x)
        {
            top = &x;
        }
    };

主要功能：

    int main()
    {
       Node a;
       Node b;
       a.setValue(1);
       b.setValue(2);
       Stack s;
       s.push(a);
       s.push(b);
       cout << s.pop().getValue() << endl;
       cout << s.pop().getValue() << endl;
       return 0;
   }

我一直得到随机数，我知道我在使用对象和指针时有问题，我就是不知道我的问题是什么

为成员变量的参数分配指针是完全无用的，因为参数从函数返回时会消失，指针也会变得毫无意义。

class Node
{
private:
    int value;
    Node *next;
public:
    Node()
   {
        value = 0;
   }
   ~Node()
   {
   }
   void setValue(int x)
   {
       value = x;
    }
    int getValue()
    {
       return value;
    }
    void setNext(Node* x)      // setNext takes a pointer, not a Node by value.
    {
        next = x;
    }
    Node *getNext()
    {
        return next;
    }
};

和

class Stack
{
private:
   Node *top;
public:
    Stack()
    {
       top = NULL;
    }
    ~Stack()
    {
    }
    Node pop()
    {
        Node *temp = top;
        top = top->getNext();
        return *temp;
    }
    void push(Node &x)
    {
        x.setNext(getTop());
        setTop(&x);
    }
    Node *getTop()
    {
        return top;
    }
    void setTop(Node *x)    // setTop takes a pointer, not a Node by value.
    {
        top = x;
    }
};

我担心这个实现可能对应用程序来说是危险的，但它在这里会起作用。

Node::setNext、Node::getNext、Stack::getTop和Stack::setTop都返回/传递值，这些值在某些时候超出了范围。应该有引用，这将导致堆栈指向原始的Node a和Node b，当它们不再使用时，它们在main末尾超出范围。

但这一切都错了您应该将副本存储在堆上，而不仅仅是指向具有自动存储持续时间的对象的指针。

让getter/setter返回指针而不是对象。此代码：

        Node *temp = top;
        top = &top->getNext();
        return *temp;

将temp分配给top，然后将top分配给由getNext()创建的临时对象的地址，然后返回temp所指向的对象。下次使用top将导致未定义的行为，因为top现在是一个悬空指针。

节点：

class Node
{
private:
    int value;
    Node *next;
public:
    Node()
   {
        value = 0;
   }
   ~Node()
   {
   }
   void setValue(int x)
   {
       value = x;
    }
    int getValue()
    {
       return value;
    }
    void setNext(Node* x)
    {
        next = x;
    }
    Node* getNext()
    {
        return next;
    }
 };

堆栈：

class Stack
{
private:
   Node *top;
public:
    Stack()
    {
       top = NULL;
    }
    ~Stack()
    {
    }
    Node pop()
    {
        Node *temp = top;
        top = top->getNext();
        return *temp;
    }
    void push(Node* x)
    {
        x->setNext(getTop());
        setTop(x);
    }
    Node* getTop()
    {
        return top;
    }
    void setTop(Node* x)
    {
        top = x;
    }
};
相关文章：