跟踪内存泄漏

andalousie

我在书上看到可以通过重载new和delete运算符实现跟踪内存泄漏。这里把我自己的例子发布出来。
用于测试的文件test.cpp
#include <iostream>
#include <cstdlib>
#if !defined NDEBUG
#include "Tracer.h"
#define new new (__FILE__, __LINE__)
Tracer NewTrace;
#endif
#include <cstring>
/************************************************
* info -- A class to hold information.         *
*                                              *
* Note:                                        *
*      Because someone is walking all over our *
*      memory and destroying our data, we      *
*      have put two guards at the beginning    *
*      and end of our class.    If someone     *
*      messes with us these numbers will       *
*      be destroyed.                           *
*                                              *
* Member functions:                            *
*      set_data -- Store a string in our data. *
*      get_data -- Get the data string. *
*      check_magic -- Check the magic numbers. *
************************************************/
// Magic numbers for the start and end of the
// data in the class info
const int START_MAGIC = 0x11223344;
const int END_MAGIC = 0x5567788;
class info
{
    private:
        // Magic protection constant
        const int start_magic;
        // String to be stored
        char data[30];
        // Magic protection constant
        const int end_magic;
    public:
        info(void):
            start_magic(START_MAGIC),
            end_magic(END_MAGIC)
            {}
        // Copy constructor defaults
        // Assignment operator defaults
        // Destructor defaults
        // Store some data in the class
        void set_data(
            // Data to be stored
            const char what[]
        )
        {
            strcpy(data, what);
        }
        // Get the data from the class
        char *get_data(void)
        {
            return (data);
        }
        // Verify that the magic
        // numbers are correct
        void check_magic(void)
        {
            if ((start_magic != START_MAGIC) ||
                (end_magic != END_MAGIC))
            {
                std::cout <<
                    "Info has lost its magic\n";
            }
        }
};
/************************************************
* new_info -- Create a new version of the      *
*      info class.                             *
************************************************/
struct info *new_info(void)
{
    struct info *result; // Newly created result.
/*    result = (struct info *)
        malloc(sizeof(struct info));
    // Make sure the structure is clear
    memset(result, '\0',  sizeof(result));*/
    result = new info;  // Use C++ new rather than C malloc
    return (result);
}
int main()
{
    // An info class to play with
    class info *a_info = new_info();
    a_info->set_data("Data");
    a_info->check_magic();
    return (0);
}
测试结果

1. *** Memory leak(s)
   
2. 0x11223344: ptr/main.cpp, line 82

复制代码

通过测试发现，在代码的第82行，也就是红色字体的，内存没有被释放。
这个代码本来是一个教学代码，如果使用绿色字体部分，而不是红色字体部分，就会输出
Info has lost its magic()
原因很简单，我们使用C语言形式的malloc分配空间不会调用构造函数，然后雪上加霜地用memset来将类置0……
对于这种问题，我只能给出一个我认为还算过得去的方案，就是使用智能指针。
我们可以自己写一个auto_ptr类，来用析构函数实现其内容的销毁。

1. #if !defined (AUTOPTR_H)
   
2. #define AUTOPTR_H
   
3. 
   
4. //-------------
   
5. // Auto pointer
   
6. //-------------
   
7. template<class T>
   
8. class auto_ptr
   
9. {
   
10.         template<class U> struct auto_ptr_ref
    
11.         {
    
12.                 auto_ptr<U> & _ap;
    
13.                 auto_ptr_ref (auto_ptr<U> & p) : _ap (p) {}
    
14.         };
    
15. public:
    
16.         typedef T element_type;
    
17. 
    
18.         explicit auto_ptr (T * p = 0) : _p (p) {}
    
19. 
    
20.         // "transfer" constructor
    
21.         auto_ptr (auto_ptr & pSrc)
    
22.         {
    
23.                 _p = pSrc._p;
    
24.                 pSrc._p = 0;
    
25.         }
    
26. 
    
27.         auto_ptr & operator= (auto_ptr & pSrc)
    
28.         {
    
29.                 reset (pSrc.release ());
    
30.                 return *this;
    
31.         }
    
32. #if 0 // not in this version of the compiler
    
33.         // "transfer" from derived class
    
34.         template<class U>
    
35.         auto_ptr (auto_ptr<U> & pSrc)
    
36.         {
    
37.                 _p = pSrc._p; // implicit cast
    
38.                 pSrc._p = 0;
    
39.         }
    
40. 
    
41.         // assignment of derived class
    
42.         template<class U>
    
43.         auto_ptr & operator= (auto_ptr<U> & pSrc)
    
44.         {
    
45.                 if (this != &pSrc)
    
46.                 {
    
47.                         _p = pSrc._p;
    
48.                         pSrc._p = 0;
    
49.                 }
    
50.                 return *this;
    
51.         }
    
52. #endif
    
53.         ~auto_ptr () { delete _p; }
    
54. 
    
55.         T & operator* () const { return *_p; }
    
56. 
    
57.         T * operator-> () const { return _p; }
    
58. 
    
59.         T * get () const { return _p; }
    
60. 
    
61.         T * release ()
    
62.         {
    
63.                 T * tmp = _p;
    
64.                 _p = 0;
    
65.                 return tmp;
    
66.         }
    
67. 
    
68.         void reset (T * p = 0)
    
69.         {
    
70.                 if (p != _p)
    
71.                 {
    
72.                         delete _p;
    
73.                         _p = p;
    
74.                 }
    
75.         }
    
76. 
    
77.         auto_ptr (auto_ptr_ref<T> apr)
    
78.                 : _p (apr._ap.release ())
    
79.         {}
    
80. 
    
81.         template<class U>
    
82.         operator auto_ptr_ref<U> ()
    
83.         {
    
84.                 return auto_ptr_ref<U> (*this);
    
85.         }
    
86. 
    
87.         template<class U>
    
88.         operator auto_ptr<U> ()
    
89.         {
    
90.                 return auto_ptr<U> (release ());
    
91.         }
    
92. private:
    
93.         T * _p;
    
94. };
    
95. 
    
96. #endif

复制代码

而把结构体的内容改成

1. struct info *new_info(void)
   
2. {
   
3.     auto_ptr<info> result(new info);
   
4.     return (result.release());
   
5. }

复制代码

在return之后就会自动调用auto_ptr类的析构函数。至于形参new info，其实在使用以后系统就会将其释放，所以我认为没有影响。或者大家以可以使用<memory>头文件里面的std::auto_ptr，这样就用不着自己写了。
如果有其他好的解决方案，请回复。

凉石

难度好大 啊