Question

• ~DecayList() – The destructor de-allocates any dynamically allocated memory.

How do I implement ~decaylist()?

#ifndef DECAYLIST_H

#define DECAYLIST_H

#include <iostream>

#include "Node.h"

using namespace std;

const int NUM_CONSECUTIVE = 3;

class DecayList{

public:

  // Constructor

  // Preconditions: None

  // Postconditions: New list is created

  DecayList();

and here is the node class.

  // Destructor

  // Preconditions: None

  // Postconditions: Dynamically allocated memory freed

  ~DecayList();

#include <iostream>

#include "Node.h"

using namespace std;

Node::Node(){

    m_next = NULL;

    m_value = NULL;

}

Node::~Node(){

    //delete the node pointer using the delete statement

    delete m_next;

    

}

Node::Node(bool value){

    m_next = NULL;

    m_value = value;

}

void Node::ReplaceValue(){

    m_value = !m_value;

}

void Node::SetNext(Node* next){

    m_next = next;

}

Node* Node::GetNext(){

    return m_next;

}

bool Node::GetValue(){

    return m_value;

}

Answer 1

Hi,

Please find a short explaination on dynamic destruction below.

important points are highlighted.

If i have understood your question correctly,
given node class , which seems to be implementing each node of singly linked list.

Assuming each nodes is dynamically allocated memory .,
while you are inserting elements into the list,
you might be using below code, using new operation to allocate memory to each node.

//Allocate a new node.
Node *toBeInsertedNode = new (std::nothrow)Node(myvalue);

which would call constructor of Node class,

so m_next = NULL;
m_value = myvalue;

so when the whole class is destroyed, we need to make sure there are no memory leaks.
All the memory allocated has to be cleaned up.

since in your program ,
Node::~Node(){
//delete the node pointer using the delete statement
delete m_next;
  
}
destructor is already cleaning up next pointers, you can call Node destructor for each node in linkedlist as below.

so i will discuss a case which wont work, and a case which should be used as an alternative.

so considering you have a pointer to first item in the list,
Node* first;
DecayList():~DecayList()
{
   Node *myPointer = first; // take a pointer to head node
   while(myPointer)
   {
       head = myPointer->GetNext();
       delete myPointer; // High Lighted code
       myPointer = first;
   }
}

this will delete all elements in the list starting from head which we usually do, will be wrong.

consider what happens on highlighted code, when we delete a node, it will delete a node it is linked to.
and in turn that node will delete the node it is linked.
Its a chain reaction!.

which means that in above code of ours, mypointer will be a invalid pointer , pointing to invalid node.

so our destructor should just be like below.
DecayList():~DecayList()
{
   delete firstOrHead; // whatever you have given name in your program, first or head pointer.
}

using delete on a null pointer is perfectly fine.

kindly upvote.