Является ли это допустимым деструктором LinkedList? Я все еще смущен ими.
Я хочу убедиться, что правильно понимаю.
LinkedList::~LinkedList()
{
ListNode *ptr;
for (ptr = head; head; ptr = head)
{
head = head->next
delete ptr;
}
}
Итак, в начале цикла указатель ptr установлен для хранения адреса головы, первого node в списке. head затем устанавливается на следующий элемент, который станет началом списка после его первого удаления. ptr удаляется, и это первый node. При первой итерации цикла указатель снова будет нажат.
Вещь, которая меня интересует, достигает самого последнего node. Условие "голова"; должен проверить, что он не является нулевым, но я не уверен, что он будет работать.
Любая помощь была оценена.
Почему бы не сделать это намного проще - с элегантным while -loop вместо того, чтобы тщательно анализировать, правильно ли перегружен for -loop?
ListNode* current = head;
while( current != 0 ) {
ListNode* next = current->next;
delete current;
current = next;
}
head = 0;
Вы можете запустить его через отладчик, или вы можете запустить его через этот бит 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 просто потому, что вы выйдете из тела цикла до этой точки (или даже не войдете в тело, если список пуст).
Любое другое значение указателя будет считаться истинным, и вы введете или продолжите тело цикла.
Условие "голова"; должен проверить, что он не является нулевым, но я не уверен, что он будет работать.
Да, "голова" сама по себе такая же, как "head!= null" - но зачем использовать бессмысленный ярлык для ввода, даже если вы считаете его запутанным? Это всего лишь еще шесть нажатий клавиш (и генерирует идентичный машинный код), поэтому идите в длинную форму.
Кроме того, ваш код немного сложнее, чем необходимо, потому что вы используете конструкцию for(). Почему бы не использовать while()? Ваш код будет намного чище.
Наконец, я понимаю, что вы делаете это как учебное упражнение, но имейте в виду, что список < > находится в стандартной библиотеке --- Связанные списки являются официальной "Решенной проблемой".
Протестировано 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;
}
Ваш код может быть правильным, вы должны попробовать запустить его, например. valgrind и посмотреть, что он говорит. Однако я бы написал следующее:
for (ListNode *current = head, *next; current; current = next) {
next = current->next;
free(current);
}
Это лучший подход для освобождения/удаления памяти с помощью деструктора Linked-List.
List()::~List()
{
for( Link* ptr= Head; Head; Head= Head->next)
{
delete ptr;
}
}