Why does the following code act the way it does?

//
//  The mystery is why does b get deleted?
//  It seems to have been tarred by its association with a.
//
//
#include <list>
#include <assert.h>
#include <string>

class Contig {

 public:
  list<Contig> left;
  list<Contig> right;
  char *id; // This is just for debug

  void AddLeft( Contig &c ) ;

  Contig( );
  ~Contig( );
};


Contig::Contig() {
  id = (char *) NULL ;
}

Contig::~Contig() {
  if ( id ) cerr << " id = " << id << endl ;
  cerr << " Here we are in ~Contig" << endl ;
  if ( id ) delete [] id;
}

void Contig::AddLeft(  Contig &c ) {

  left.push_front( c ) ;
  c.right.push_front( *this ) ;
}

//
//  My goal is to set up a simple graph structure,
//  each element (or member of the class Contig)
//  may have Contigs on the left and on the right.
//  The structure should be symmetrical (or doubly-linked)
//  in that if a is on the right of b, then b is on the
//  left of a.  
//
//  b - a
//
//  In other words, b is to the left a and a is to the right
//  of b.
//
main(){

  Contig *a = new Contig;
  a->id = "A";
  Contig *b = new Contig;
  b->id = "B";

  a->AddLeft(*b);    // In essence, this sets a->left = b and a->right = a
                     // If I comment out this line, b does not get deleted

  delete a;          // This line deletes both a and b - Why?
  cerr << " We are at the bottom now " << endl ;
}

<
klopterAsked:
Who is Participating?
 
tomkeaneConnect With a Mentor Commented:
It looks like you want to change your class definition a bit so that the objects are keeping a list of pointers to their adjacecent objects.  Currently you are storing a list of copies of the adjacent objects.

Change:
  list<Contig> left;
  list<Contig> right;
to:
  list<Contig*> left;
  list<Contig*> right;
 
and change AddLeft() to :

void AddLeft( Contig * c )
{
  left.push_front( c );
  c.right.push_front( this );
}

0
 
KangaRooCommented:
I suspect the output may be deceiving you. The problem I spot is with deleting id. Basically the flow is

id = "A"; // in main

delete [] id; // in ~Contig

You're deleting something that must not be deleted. After that, anything may happen (output can not be trusted)
0
 
mgdPaulCommented:
I might say the same as Kangaroo.

a is calling it's function and passes b. In the function you use b to push a to the front, bnut only a pointer to it. Then you delete a, and so b points to nothing.

If I understand push_front right, that is.
0
The 14th Annual Expert Award Winners

The results are in! Meet the top members of our 2017 Expert Awards. Congratulations to all who qualified!

 
pitonyakCommented:

Why do you believe that b is being deleted? It is not.

To see this, print the address of the object as it is being destroyed. Also, print the value of  a and b (note that this means print the value of the pointers, not *a and *b).

Ultimately, you are storing a copy of *a and a copy of *b in the lists.

Some notes:
1) The destructor contains the code: delete [] id (as mentioned by KangaRoo). If you did not dynamically allocate this memory then do not do this. You can avoid this problem by creating a set function.....
void Contig::setId(const char* c) {
    delete[] id;
    id = 0;
    if (c != 0) {
        id = new char[strlen(c)];
        strcpy(id, c);
    }
}
 


2) Remember that I said you storing a copy of *b, not b itself. Well, this means that the default copy constructor is being used to make this copy. You can see this by implementing your own copy constructor, which you should do anyway. This way, you can safely copy pointers.

const Contig& Contig::copy(Contig& x) {
  if (this != &x) {
    setId(x.id);  // this uses the safe version above.
    left = x.left;
    right = x.right;
  }
  cout << "I am in the copy constructor" << endl;
  return *this;
}

Now, when you delete a, the destructor is called on a->left and a->right. This contains a copy of both *a and *b so I would expect to see the destructor called for an "A" and a "B". Of course when this happens now you are deleting memory that was never allocated which is grounds for instant failure.

I am rambling.... so ttfn

Andy
0
 
harish791Commented:
It could be that when ~Contig is called, the destructor for the list members(left and right ) is getting called. if the list's destructor deletes elements in the list then b would also get deleted since it is in the left. note that in function addLeft what went in was reference to b.
0
 
klopterAuthor Commented:
Yes. Yes. Yes.  You nailed by mistake.

Thanks,

  Ken
0
Question has a verified solution.

Are you are experiencing a similar issue? Get a personalized answer when you ask a related question.

Have a better answer? Share it in a comment.

All Courses

From novice to tech pro — start learning today.