[C++]野指针的产生以及应对办法

很大程度上,野指针都是因为编码不善,习惯不好所产生的.

要解决野指针,就要养成好习惯,不要动不动就public数据成员,所有的数据访问都抽象成接口,最好只在一个地方delete数据.

前段时间游戏技术测试,down机无限,搞的很头疼.后来用valgrind的memcheck工具,找到很多野指针.

valgrind很好用,除了有一点慢:-)

valgrind --tool=memcheck --leak-check=full --log-file=./log_file.log --showpossibly-lost=no --malloc-fill=0xff --free-fill=0x11 ./execFile

用上面的语句,就可以启动一个execFile,顺便把所有malloc内存设置成0xff,free内存设置成0x11,还会统计内存泄露(在log_file.log内).简单易用.

然后么,一个一个去fix....

跟同学交流,他们那边有一个办法,去解决这个野指针问题,也是很巧妙的,不敢独享:-D

A对象会被n个其他对象B引用,就是其他n个对象B会持有指向A的指针.

如果A被delete,其他n个对象B指向A的指针的内存已经不可访问,这个时候访问那块内存,就会发生未定义行为.

天知道会怎么样!!!也许会down掉,也许不会.

他们是搞的:

1) 对象B对A的引用,A自己会保存一份记录,标记有对象B引用过自己

2) 对象B析构,会通知A,这个时候,A会去除B对自己的引用的标记

3) A析构,A会把所有指向自己的指针,设置成NULL

这是基本思想.

下面给出简单的实现,非线程安全,有什么问题可以提出...

#ifndef __REFERABLE_H__
#define __REFERABLE_H__

#include <vector>
#include "ref_ptr.h"

template<typename T>
class referable
{
public:    
    typedef referable** RefAddress;
    virtual ~referable()
    {
        for (container_iter iter = m_references.begin();
            iter != m_references.end();
            ++iter)
        {
            **iter = NULL; 
        }
    }
private:
    typedef typename std::vector<RefAddress> container_type;
    typedef typename container_type::iterator container_iter;

    friend class ref_ptr<T>;
    void on_reg(RefAddress addr)
    {
        for (container_iter iter = m_references.begin();
            iter != m_references.end();
            ++iter)
        {
            if(*iter == addr) return;
        }
        m_references.push_back(addr);
    }
    void on_unreg(RefAddress addr)
    {
        for (container_iter iter = m_references.begin();
            iter != m_references.end();)
        {
            if(*iter == addr)
                iter = m_references.erase(iter);
            else
                ++iter;
        }
    }
private:
    container_type m_references;
};
#endif

#ifndef __REFERENCE_POINTER_H__
#define __REFERENCE_POINTER_H__
#include "referable.h"

template<typename T>
class ref_ptr
{
public:
    ref_ptr():m_ptr(NULL){}
    ref_ptr(T *ptr):m_ptr(ptr)
    {
        add_ref();
    }
    ref_ptr(const ref_ptr<T>& ref):m_ptr(ref.m_ptr)
    {
        add_ref();
    }
    virtual ~ref_ptr()
    {
        remove_ref();
    }

    ref_ptr<T>& operator = (const ref_ptr<T>& ref)
    {
        if(this == &ref) return *this;
        remove_ref();
        m_ptr = ref.m_ptr;
        add_ref();
        return *this;
    }
    ref_ptr<T>& operator = (T *ptr)
    {
        if(m_ptr != ptr)
        {
            remove_ref();
            m_ptr = ptr;
            add_ref();
        }
        return *this;
    }
public:
    T*  operator->() const { return m_ptr; }
    T&  operator*() const { return *m_ptr; }
    operator T*() const { return m_ptr; }
    operator bool() const { return m_ptr; }
private:
    void add_ref()
    {
        if(m_ptr) ((referable<T>*)m_ptr)->on_reg((referable<T>**)&m_ptr);
    }
    void remove_ref()
    {
        if(m_ptr) ((referable<T>*)m_ptr)->on_unreg((referable<T>**)&m_ptr);
        m_ptr = NULL;
    }

private:
    T* m_ptr;
};

#endif

测试代码:

class object : public referable<object>
{
public:
    int x;
};

void test()
{
    object *a = new object;
    object *a1 = new object;
    ref_ptr<object> b = a;
    a->x = 10;
    assert(b && b->x == 10);

    delete a;
    assert(!b);

    b = a1;
    assert(b);
}

这个东西看上去还不错.

不过习惯还是很重要滴

PS:

一般引用都是只有四五个,所以vector性能足够好,我测试过~~