Question

我无法弄清楚为什么我的一个项目列表“_head-＆gt; next”未被设置为null（nullptr）。我可以混淆我的尾巴和头指针吗？这是一个双重链表。大多数其他指针都有效，但是这个错误/错误在遍历列表时会引发seg错误。

#pragma once
class dlist {
  public:
    dlist() { }

  struct node {
    int value;
    node* next;
    node* prev;
  };


  node* head() const { return _head; }
  node* tail() const { return _tail; }


void insert(node* prev, int value){
     //if empty
     if(prev == nullptr)
       {
       //create node/prepare to insert into head ptr
        _head = new node{value, _head, nullptr};

        if(_tail == nullptr)
        {
         _tail = _head;
         _tail->next = nullptr;
        }
        //set head
        if(_head->next != nullptr)
          {
           _head->prev = _head;

           _head->next = nullptr;
           //_head->next->next = nullptr;
           //above doesn't work  
          }
       }
 //if not empty
     else
       {
       //create and set new node
        node* node1 = new node{value, prev->next, nullptr};
        prev->next = node1;

        //check if null, to make sure inserting after a filled "space"
         if(node1->next != nullptr)
           {
            node1->next->prev = node1;

            //set to end or tail
            if(prev == _tail)
              {
               _tail = node1;
               _tail->next = nullptr;
              }
           }
       }
  }


 private:
   node* _head = nullptr;
   node* _tail = nullptr;

};

Answer 1

根据您发布的初始代码以及使用prev作为insert参数的模糊性，这是一个很难理解的问题。

首先，insert是dlist的成员函数，可以直接访问_head和_tail。 node*您不需要insert参数，因为您对链表的唯一关注是检查_head是否为nullptr并为value分配/分配_head iter->next，或者您将迭代到nullptr为iter->next，并将分配的节点添加为_tail设置class到新分配的节点。

坦率地说，你现有的大部分代码都让我摸不着头脑。此外，private的默认值为public，因此通常您只需指定class dlist { struct node { int value; node* next; node* prev; }; node* _head = nullptr; node* _tail = nullptr; public: dlist() { } node* head() const { return _head; } node* tail() const { return _tail; } void insert (int value) { node *newnode = new node {value, nullptr, nullptr}; if (_head == nullptr) _head = newnode; else { node* iter = _head; for (; iter->next; iter = iter->next) {} newnode->prev = iter; _tail = iter->next = newnode; } } };个成员。

将逻辑放在一起，您可以执行以下操作：

_head

当你在类中分配内存时，为了防止像筛子一样泄漏内存，你还需要声明一个析构函数，它将释放你在类的实例超出范围时分配的内存。不需要任何花哨的东西，只需从delete迭代到列表末尾和delete节点。

（注意：除非您保存对下一个节点的引用，否则不得victim对当前节点的引用，因此请使用另一个名称恰当的delete节点执行~dlist() { node* iter = _head; while (iter) { node* victim = iter; iter = iter->next; delete victim; } }）

您可以执行以下操作：

print

完全放置并向rprint添加一些函数并反向或#include <iostream> using namespace std; class dlist { struct node { int value; node* next; node* prev; }; node* _head = nullptr; node* _tail = nullptr; public: dlist() { } ~dlist() { node* iter = _head; while (iter) { node* victim = iter; iter = iter->next; delete victim; } } node* head() const { return _head; } node* tail() const { return _tail; } void insert (int value) { node *newnode = new node {value, nullptr, nullptr}; if (_head == nullptr) _head = newnode; else { node* iter = _head; for (; iter->next; iter = iter->next) {} newnode->prev = iter; _tail = iter->next = newnode; } } void print () { for (node* iter = _head; iter; iter = iter->next) cout << " " << iter->value; cout << "\n"; } void rprint() { for (node* iter = _tail; iter; iter = iter->prev) cout << " " << iter->value; cout << "\n"; } }; int main (void) { dlist list; int tmp; while (cin >> tmp) list.insert(tmp); list.print(); list.rprint(); }列表，您可以执行以下操作：

$ echo "2 3 4 6 8 10" | ./bin/dlist
 2 3 4 6 8 10
 10 8 6 4 3 2

示例使用/输出

valgrind

内存使用/错误检查

在您编写的任何动态分配内存的代码中，您有2个职责关于分配的任何内存块：（1）始终保留指针或对起始地址的引用对于内存块，（2）当不再需要时，它可以释放。

必须使用内存错误检查程序以确保正确使用分配的内存，并确认释放已分配的所有内存。

对于Linux $ echo "2 3 4 6 8 10" | valgrind ./bin/dlist ==18878== Memcheck, a memory error detector ==18878== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. ==18878== Using Valgrind-3.13.0 and LibVEX; rerun with -h for copyright info ==18878== Command: ./bin/dlist ==18878== 2 3 4 6 8 10 10 8 6 4 3 2 ==18878== ==18878== HEAP SUMMARY: ==18878== in use at exit: 0 bytes in 0 blocks ==18878== total heap usage: 9 allocs, 9 frees, 77,968 bytes allocated ==18878== ==18878== All heap blocks were freed -- no leaks are possible ==18878== ==18878== For counts of detected and suppressed errors, rerun with: -v ==18878== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)是正常的选择。每个平台都有类似的记忆检查器。它们都很简单易用，只需通过它运行程序即可。

rules: {
    yourField:{
        regex: /^[0-9!?.;,]+$/
    }
}

始终确认已释放已分配的所有内存并且没有内存错误。

Answer 2

我强烈建议不再在 C ++ 中使用 C风格的指针。 C ++ 具有智能指针，可为您完成所有内存管理。

将您的节点更改为：

class node {
    node(int value) : value{value} {}
    int value;
    std::shared_ptr<node> next;
    std::weak_ptr<node> prev;
};

shared_ptr只要没有自身的副本/实例就会删除它所拥有的对象（它使用一个简单的计数器）。 weak_ptr确保您没有循环引用，这意味着您的节点永远不会被删除。

同样在 dlist 类中，相应地更改成员：

std::shared_ptr<node> _head;
std::weak_ptr<node> _tail;

然后将你的吸气剂改为：

std::shared_ptr<node> head() const { return _head; }
std::shared_ptr<node> tail() const { return _tail.lock(); }

weak_ptr::lock()会增加它所属的shared_ptr计数器并返回一个新的shared_ptr，然后可以访问它而不会丢失对象的风险。如果该对象已被删除，则会返回 empty shared_ptr。

然后像这样更改插入方法：

void insert (int value)
{
    std::shared_ptr<node> newnode = std::make_shared<node>(value);

    if (_tail) {
        newnode->prev = _tail;
        _tail->next = newnode;
        _tail = newnode;
    }
    else {
        _head = newnode;
        _tail = newnode;
    }
}

如果列表为空，这会将 _head 和 _tail 设置为 newnode ，否则将其添加到列表的末尾。

在此处详细了解shared_ptr和weak_ptr。

//编辑：如果您想要清除列表，只需执行_head = nullptr;即可。这将导致shared_ptr减少它的引用计数器并删除它所持有的node（如果计数器变为0），从而删除该节点中的shared_ptr<node> next;，依此类推。只要_tail所属的shared_ptr被解构，_tail = nullptr;就会自动为空。为了确保您的dlist类处于干净的空状态，您仍应该调用shared_ptr，因为代码的其他部分可以将_tail保存到任何节点，从而保持X 1}}在列表类中处于活动状态，除非您明确清除它。

head-＆gt; next不为null

2 个答案: