Question

I’m writing a class that holds a pointer to a parent object of the same type (think Qt’s QObject system). Each object has one parent, and the parent should not be destroyed when a child is destroyed (obviously).

class MyClass
{
public:
    MyClass(const MyClass* ptr_parent): parent(parent){};
    ~MyClass(){ delete[] a_children; };
private:
    const MyClass* ptr_parent; // go to MyClass above
    MyClass* a_children; // go to MyClass below
    size_t sz_numChildren; // for iterating over a_children
}

(Excuse my inline coding, it’s only for brevity)

Will destroying the “Master MyClass” take care of all children? No child should be able to kill it’s parent, because I would then have pointers in my main program to destroyed objects, correct?

Why might you ask? I need a way to “iterate” through all subdirectories and find all files on a platform independent level. The creation of this tree will be handled by native API’s, the rest won’t. Is this a good idea to start with?

Thanks!

Answer 1

This concept is fine, but there are a number of things wrong with the code you posted (although I gather from your comment about “inline coding” that you just wrote this on the fly rather than copying it out of a compilable program).

1. You will need to have a_children be an array of MyClass pointers, so it will need to have type MyClass**, and you will need to allocate it an reallocate it appropriately as children are added.

2. delete[] a_children will not delete the children, it will delete the array that holds the pointers to the children. You must, in the MyClass destructor, iterate over the array, deleting each child pointer, and then delete the array. In fact, it would probably be a better idea to use a std::vector<MyClass*> for a_children instead of MyClass*, so then you don’t have to worry about (1). But even with a vector, you will still need to iterate and delete each child in the destructor.

3. Your children will need to “register” with their parent object somehow. The way you have written this, there is no way for the child object to tell the parent object that it exists. For this reason you probably will not be able to get away with passing a const parent pointer.

So, as an example:

class MyClass {

public:

  MyClass(MyClass* parent) 
    : m_parent(parent) 
  { 
    if (m_parent) m_parent->registerChild(this); 
  }

  ~MyClass() 
  {
    for (std::vector<MyClass*>::const_iterator i = m_children.begin(); 
         i != m_children.end(); ++i) 
    {
      delete *i;
    }
  }

  void registerChild(const MyClass* child) 
  {
    m_children.push_back(child);
  }

private:

  MyClass* m_parent;
  std::vector<const MyClass*> m_children;
};

Note that this does not take into account the possibility that children will be destroyed by any means other than destroying their parent.