Question

我似乎无法理解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;
   }

我不断得到随机数字，我知道使用对象和指针时遇到问题，我只是无法弄清楚我的问题是什么

Answer 1

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

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

我担心这种实现对于应用程序可能是危险的，但这可以在这里工作。

Answer 2

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

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

Answer 3

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

使用指针表示堆栈

3 个答案: