在查看boost庫時發現一個小文件checked_delete.hpp裏面幾個小函數，它的作用用很簡短的話來說：防止未定義的行為造成delete時的內存泄露。實現如下：

template<class T> inline void checked_delete(T * x)
{
    // intentionally complex - simplification causes regressions
    typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
    (void) sizeof(type_must_be_complete);
    delete x;
}

template
 
<class T> inline void checked_array_delete(T * x)
{
    typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
    (void) sizeof(type_must_be_complete);
    delete [] x;
}

template<class T> struct checked_deleter
{
    typedef void result_type;
    typedef T * argument_type;

    
 
void operator()(T * x) const
    {
        // boost:: disables ADL
        boost::checked_delete(x);
    }
};

template<class T> struct checked_array_deleter
{
    typedef void result_type;
    typedef T * argument_type;

    void operator()(T * x) const
    {
        boost::checked_array_delete(x);
    }
};
 

　　先看看下面這一種用例：

// filename : object.h

class Object
{
public:
    Object();
    ~Object();
};

// filename : object.cpp
#include <stdio.h>
#include "object.h"

Object::Object()
{
    printf("%s\n", "A::A()");
}

Object::~Object()
{
    printf("%s\n", "A::~A()");
}

// filename : del.h
class Object;

void delete_obj(Object* obj) { delete obj; }

下面在main中實現我們的測試：

#include<iostream>
#include "del.h"
#include "object.h"
#include<boost/checked_delete.hpp>
#include<boost/make_shared.hpp>

int main() {
    Object* p = new Object();
    delete_obj(p);       return 0;
}

　　這樣的代碼實現delete方式是無法調用析構函數，所以就有了下面這一行

boost::checked_delete(p);

　 這樣寫就可以正常調用了，另外出於好奇，測試了一下使用shared_ptr，看情況如何：

boost::shared_ptr<Object> obj(new Object);
    boost::shared_ptr<Object> obj2(new Object[10], [](Object* pObj) { delete[] pObj; });

　　發現在程序結尾都順利地調用了析構函數。

　　所以使用shared_ptr是很不錯的選擇，當然，使用checked_delete可能讓你的代碼更加明確是要釋放內存的，代碼也顯得緊湊。

boost庫checked_delete的使用