destructors
I am creating a linked link program which created a segmentation fault
and a core at the end of the program. The program is trying to delete an
already deleted object, and I can't seem to protect my program from
this. I fixed the problem by sending an object to a function by
reference rather than by value, but I'm not satisfied with the solution.
The list has node objects
namespace chainlist {
/*
* =====================================================================================
* Class: Node
* Description: This is a node in the "List" Link List
* =====================================================================================
*/
template < class unk >
class Node
{
public:
// ==================== LIFECYCLE =======================================
/* constructor */
Node<unk>( unk value, Node<unk> *item_to_link_to = 0);
Node ( const Node &other ); /* copy constructor - Need to write this! */
~Node<unk> (); /* destructor */
/* ==================== ACCESSORS ======================================= */
inline unk* value ()const{
return value_;
}
inline Node<unk> * next()const {
return next_;
}
inline void value(unk *);
inline void value(unk);
inline void next(Node<unk> *);
/* ==================== MUTATORS ======================================= */
/* ==================== OPERATORS ======================================= */
Node& operator=( const Node &other ); // assignment operator
unk& operator*(){ //gain access to real value
return *(value());
}
unk& operator*(unk);
protected:
/* ==================== DATA MEMBERS ======================================= */
private:
/* ==================== DATA MEMBERS ======================================= */
unk * value_ ;
Node * next_;
}; /* ----- end of template class Node ----- */
And they are controlled by a List Object
template < class T >
class List
{
public:
/* ==================== LIFECYCLE ======================================= */
List<T>(): front_(0),end_(0), cursor_(0), size_(0){} /* constructor */
void remove_all();
~List<T>();
/* ==================== ACCESSORS ======================================= */
int size()const { return size_; }
inline Node<T>* const &front()const{ return front_;}
inline Node<T>* &endd(){return end_;}
inline Node<T> *& cursor(){return cursor_;}
inline void cursor(Node<T> * a){ cursor_ = a; }
inline void endd(Node<T> *a){ end_ = a; }
inline void front(Node<T> *a){ front_ = a; }
inline void display();
/* ==================== MUTATORS ======================================= */
inline void sizeup(){ ++size_; }
inline void sizedown(){ --size_; }
void insert_front( T value); //add a node to the front
void insert(T value, Node<T> * &place_after_this); //add a new node after the Node given and return the new node
void insert(T value); //add a new node at the end of the list
void insert_end(T value); // Add a new node to the end
void find_value(T value); //find a value from it's first occurance in the list
Node<T>& find_next_value(const T& value, Node<T>& last_node_searched); //find a value in the list after the
//current node which is not searched
void remove_node_by_value(T value);
void remove_node_by_node(Node<T> cur);
void remove_node_front();
void remove_node_end();
/* ==================== OPERATORS ======================================= */
protected:
/* ==================== DATA MEMBERS ======================================= */
private:
/* ==================== DATA MEMBERS ======================================= */
Node<T> * front_;
Node<T> * end_;
Node<T> * cursor_;
int size_;
}; /* ---------- end of template class Lists ---------- */
The destructors are defined as follows
template<class unk>
Node<unk>::~Node(){
if(value_)
delete value_;
std::cout << "Delete Node" << std::endl;
}
template<class T>
List<T>::~List<T>(){
remove_all();
std::cout << "Deleted All*************" << std::endl;
}
And remove all looks like this
template< class T>
void List<T>::remove_all(){
cursor() = front();
Node<T> * tmp;
while(cursor() != endd()){
tmp = cursor();
cursor() = cursor()->next();
if(tmp)
delete tmp;
}
std::cout << "\n\nReached the End\n\n";
tmp = cursor(); //last node
if(tmp)
delete tmp;
cursor() = 0; //park the cursor
}
I created a large list to test my find functions and passed it by value to main.
Then passed it by value to a find testing function. when the program ends,
it seems to delete all the nodes from the List twice, once from the local
program and then from main.
Sending it by reference fixed the problem, but I can see other instances
where this can be a huge problem, such as if I decide o delete an
individual node from the list. There has to be a better strategy for
handling this issue.
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]