Написание деструктора LinkedList?

Является ли это допустимым деструктором LinkedList? Я все еще смущен ими.

Я хочу убедиться, что правильно понимаю.

 LinkedList::~LinkedList()
 {
   ListNode *ptr;

   for (ptr = head; head; ptr = head)
   {
     head = head->next
     delete ptr;
   }
}

Итак, в начале цикла указатель ptr установлен для хранения адреса головы, первого node в списке. head затем устанавливается на следующий элемент, который станет началом списка после его первого удаления. ptr удаляется, и это первый node. При первой итерации цикла указатель снова будет нажат.

Вещь, которая меня интересует, достигает самого последнего node. Условие "голова"; должен проверить, что он не является нулевым, но я не уверен, что он будет работать.

Любая помощь была оценена.

Ответ 1

Почему бы не сделать это намного проще - с элегантным while -loop вместо того, чтобы тщательно анализировать, правильно ли перегружен for -loop?

ListNode* current = head;
while( current != 0 ) {
    ListNode* next = current->next;
    delete current;
    current = next;
}
head = 0;

Ответ 2

Вы можете запустить его через отладчик, или вы можете запустить его через этот бит wetware внутри вашего черепа - обе показывают, что он работает нормально. Например, начните со списка:

head(47) -> [47]single_node -> [NULL]end-of-list.

Запуск этого списка через ваши утверждения:

ptr = head устанавливает ptr в 47.
head не равен нулю, поэтому введите цикл.
head = head->next устанавливает head в NULL.
delete ptr удалит single_node.
ptr = head устанавливает ptr в NULL.
head теперь NULL (0), поэтому цикл выхода.

Там вы идете, вы удалили единственную запись в списке, а head теперь установлена в NULL. Это все, что вам нужно сделать.

Вы можете сделать что-то похожее с более длинным списком или пустым списком, вы все равно будете в порядке (нет никакой реальной разницы между списком из одного элемента и списком из пятидесяти элементов).

В стороне, я не большой поклонник обработки указателей как булевых - я бы предпочел написать это как-то вроде:

for (ptr = head; head != NULL; ptr = head)

Это делает код читаемым лучше, на мой взгляд, и вы действительно не жертвуете какой-либо производительностью (если у вас нет мозгового компилятора). Но это вопрос вкуса.

Ваш комментарий:

Вещь, которая меня интересует, достигает самого последнего node. Условие "голова"; должен проверить, что он не является нулевым, но я не уверен, что он будет работать.

Это сработает. Значение нуля будет считаться ложным, поэтому вы обнаружите, что вы никогда не разыгрываете head- > next, когда голова NULL просто потому, что вы выйдете из тела цикла до этой точки (или даже не войдете в тело, если список пуст).

Любое другое значение указателя будет считаться истинным, и вы введете или продолжите тело цикла.

Ответ 3

Условие "голова"; должен проверить, что он не является нулевым, но я не уверен, что он будет работать.

Да, "голова" сама по себе такая же, как "head!= null" - но зачем использовать бессмысленный ярлык для ввода, даже если вы считаете его запутанным? Это всего лишь еще шесть нажатий клавиш (и генерирует идентичный машинный код), поэтому идите в длинную форму.

Кроме того, ваш код немного сложнее, чем необходимо, потому что вы используете конструкцию for(). Почему бы не использовать while()? Ваш код будет намного чище.

Наконец, я понимаю, что вы делаете это как учебное упражнение, но имейте в виду, что список < > находится в стандартной библиотеке --- Связанные списки являются официальной "Решенной проблемой".

Ответ 4

Протестировано OK

Деструктор для списка классов

List::~List()
{
    Node *n = this->front, *current = NULL; //initialization part

    while(n)                               //start cleanup of nodes of the list
    {
        current = n;
        n=n->next;
        delete(current);
    }

    front = end = NULL;
}

Ответ 5

Ваш код может быть правильным, вы должны попробовать запустить его, например. valgrind и посмотреть, что он говорит. Однако я бы написал следующее:

for (ListNode *current = head, *next; current; current = next) {
    next = current->next;
    free(current);
}

Ответ 6

Это лучший подход для освобождения/удаления памяти с помощью деструктора Linked-List.

List()::~List()
            {
                for( Link* ptr= Head; Head; Head= Head->next)
                {
                    delete ptr;
                }
            }