I''m trying to implement a doubly linked list for my upcoming engine. Since it''s going to be the key to my organization, I''d like to make sure there are no kinks in it before I start trying to add features. I''d hate to run into unnecessary problems later on.
So, this is where I was hoping a few other people could read over my code and point out my (inevitable) mistakes. I''ll admit beforehand that this was inspired by open source code and although I''ve taken the time to read and understand all the workings and rewrite (not copy-and-paste) it, it may not be perfect. Please be gentle
I''m not trying to push anyone into reading or rewriting my code, I would just appreciate some advice and for anyone who notices a problem to point it out to me. If you have something personal you''d like to say:
go here. (Please realize i was
never very good with pointers)
class CNode
{
//-----------------------------------------------------
// members
//-----------------------------------------------------
public:
CNode *pParent;
CNode *pChild;
CNode *pPrev;
CNode *pNext;
//-----------------------------------------------------
// member functions
//-----------------------------------------------------
public:
bool HasParent()
{
if(pParent != NULL)
return TRUE;
else
return FALSE;
} // end HasParent
bool HasChild()
{
if(pChild != NULL)
return TRUE;
else
return FALSE;
} // end HasChild
CNode * FindRoot() { return(pParent ? pParent->FindRoot() : this); }
public:
void Attach(CNode *pNewNode);
void AttachTo(CNode *pNewParent);
void Detach();
//-----------------------------------------------------
// constructors
//-----------------------------------------------------
public:
CNode() : pParent(NULL), pChild(NULL)
{
pPrev = pNext = NULL;
} // end CNode
CNode(CNode *pAttachNode) : pParent(NULL), pChild(NULL)
{
pPrev = pNext = NULL;
AttachTo(pAttachNode);
} // end CNode
//-----------------------------------------------------
// destructors
//-----------------------------------------------------
public:
virtual ~CNode()
{
Detach();
while(pChild)
{
delete pChild;
}
} // end ~CNode
};
//---------------------------------------------------------------------------------------------
void CNode::Attach(CNode *pNewNode)
{
// if new node already has a parent, detach it
if(pNewNode->HasParent())
pNewNode->Detach();
pNewNode->pParent = this;
// if there''s a child, do lots of re-arranging
if(pChild)
{
CNode *p0 = pChild;
CNode *p1 = pChild->pPrev;
CNode *p2 = pNewNode;
CNode *p3 = pNewNode->pPrev;
p0->pPrev = p3; p3->pNext = p0;
p1->pNext = p2; p2->pPrev = p1;
}
else
// otherwise..
pChild = pNewNode;
} // end Attach
//---------------------------------------------------------------------------------------------
void CNode::AttachTo(CNode *pNewParent)
{
// if node already has a parent, detach
if(this->HasParent())
Detach();
pParent = pNewParent;
// if the new parent has a child, more re-arranging
if(pParent->HasChild())
{
CNode *p0 = pParent->pChild;
CNode *p1 = pParent->pChild->pPrev;
CNode *p2 = this;
CNode *p3 = pPrev;
p0->pPrev = p3; p3->pNext = p0;
p1->pNext = p2; p2->pPrev = p1;
}
else
// otherwise..
pParent->pChild = this;
} // end AttachTo
//---------------------------------------------------------------------------------------------
void CNode::Detach()
{
// if this node is the first child of the parent
// make the parent point to the next child in the list
if(pParent && (pParent->pChild == this))
pParent->pChild = (pNext == NULL) ? NULL : pNext;
// exclude it from the tree
pNext->pPrev = NULL;
pPrev->pNext = NULL;
pPrev = NULL;
pNext = NULL;
pParent = NULL;
} // end Detach
//---------------------------------------------------------------------------------------------
Thanks for any help in advance.
// "Programmers don''t byte, they nibble a bit."
// chimaera
