Why does the following code act the way it does?

Posted on 2000-03-22
Last Modified: 2010-04-10
//  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 {

  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.

  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 ;

Question by:klopter

Expert Comment

ID: 2645436
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)

Expert Comment

ID: 2645738
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.

Accepted Solution

tomkeane earned 100 total points
ID: 2645974
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.

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

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

Master Your Team's Linux and Cloud Stack

Come see why top tech companies like Mailchimp and Media Temple use Linux Academy to build their employee training programs.


Expert Comment

ID: 2646890

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(;  // 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


Expert Comment

ID: 2647786
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.

Author Comment

ID: 2649536
Yes. Yes. Yes.  You nailed by mistake.



Featured Post

Best Practices: Disaster Recovery Testing

Besides backup, any IT division should have a disaster recovery plan. You will find a few tips below relating to the development of such a plan and to what issues one should pay special attention in the course of backup planning.

Question has a verified solution.

If you are experiencing a similar issue, please ask a related question

Unlike C#, C++ doesn't have native support for sealing classes (so they cannot be sub-classed). At the cost of a virtual base class pointer it is possible to implement a pseudo sealing mechanism The trick is to virtually inherit from a base class…
In days of old, returning something by value from a function in C++ was necessarily avoided because it would, invariably, involve one or even two copies of the object being created and potentially costly calls to a copy-constructor and destructor. A…
The viewer will learn how to user default arguments when defining functions. This method of defining functions will be contrasted with the non-default-argument of defining functions.
The viewer will be introduced to the technique of using vectors in C++. The video will cover how to define a vector, store values in the vector and retrieve data from the values stored in the vector.

773 members asked questions and received personalized solutions in the past 7 days.

Join the community of 500,000 technology professionals and ask your questions.

Join & Ask a Question