破坏 null 指针时的访问冲突

Question

The problem I am having is that when my class CLimb runs its destructor, if member *parent is NULL I get an "Access violation writing location 0xcccccccc" error, after the destructor is called, but before the body is executed.

limb.h

class CLimb
{
public:
    CLimb(void);
    CLimb(CLimb *_parent);
    ~CLimb(void);

    float cut;
    float bone;
    float resistance;

    CLimb *parent;
};

limb.cpp

#include "limb.h"


CLimb::CLimb(void) :
    cut(0),
    bone(0),
    resistance(0)
{
    parent = NULL;
}

CLimb::CLimb(CLimb *_parent) :
    cut(0),
    bone(0),
    resistance(0)
{
    parent = _parent;
}

CLimb::~CLimb(void)
{
}

I was also wondering if I had 2 instances, limb01 and limb02 , where limb02 is the parent of limb01 , if limb02 is deleted limb01->parent now points to an incorrect address. How would I resolve this? Would I have to add a *child pointer as well?

Answer 1

Smart pointers are a solution. In particular, you can use a weak pointer here. A weak pointer is automatically reset when the reference count of the pointed-to object drops to zero (ie when it's deleted).

Answer 2

I assume your problem is that you are accessing the pointer after deleting it. So you need to keep track of which pointers point to valid objects, and which to dead ones.

There are several ways to resolve such problems more or less automatically.

A popular one would be using some kind of smart pointers, for example, shared_ptr . This would ensure that an object won't be deleted if there are still references to it.

Another approach is to establish a hierarchy: make each parent control the lifetime of its children. This means that (1) the children need to be deleted in the parent's destructor, and (2) no one except the parent should keep a pointer to a child (at least, for a long time).

Yet another popular approach would be using garbage collection, but I wouldn't recommend it in non-managed environments.