Question

我有一个用C ++表示节点的类，但是用std::cout将输出打印到时，我看到了一个奇怪的问题。这是课程：

class NodeInt
{
    public:
        int value;
        NodeInt* left;
        NodeInt* right;

        NodeInt()
        {
            left    = NULL;
            right   = NULL;
        };

        NodeInt(int val)
        {
            value = val;
            left    = NULL;
            right   = NULL;
        };

        void setValue(int val)
        {
            value = val;
        };

        void insertNode(int val)
        {
            if(val <= value )
            {
                if(left == NULL)
                {
                    NodeInt newNode;
                    newNode.setValue(val);
                    left = &newNode;
                }
                else
                {
                    left->insertNode(val);
                }
            }
            else
            {
                if(right == NULL)
                {
                    NodeInt newNode;
                    newNode.setValue(val);
                    right = &newNode;
                }
                else
                {
                    right->insertNode(val);
                }
            }
        };
};

主要内容在这里：

int main()
{
    NodeInt firstN;
    firstN.setValue(27);
    firstN.insertNode(11);
    firstN.insertNode(29);
    firstN.insertNode(10);

    /**std::cout << firstN.value << std::endl;
    std::cout << firstN.left->value << std::endl;
    std::cout << firstN.right->value << std::endl;
    **/

    NodeInt* n = firstN.left;
    n = (n->left);
    std::cout << n->value << std::endl;

    return 0;
}

现在您将看到我注释了三个std :: cout行。因为如果我现在运行该程序，它将输出正确的值10。但是，如果我取消注释这些行，它将把10更改为2130567168。图片显示了我的意思：

有什么作用？

Answer 1

您将Node的两个指针设置为指向insertNode()中的函数局部变量，当执行到达它们所定义的块的末尾时这些变量将消失。您得到的输出是真是幸运。

如果要进行手动内存管理，则必须使用new和delete，并且您的班级需要一个复制构造函数，一个复制分配运算符和一个析构函数。请阅读The Rule of the Big Three (and a half)和The Rule of the Big Four (and a half)（又称3/5规则）。

但是，如果您希望生活更轻松，则可以查找智能指针以及如何使用它们，并遵循The Rule of Zero。

std :: cout的怪异行为

1 个答案: