linux中，由於使用malloc或alloc而沒有free掉申請的記憶體，就會造成記憶體的洩露。通常，來講為了避免記憶體洩露的情況出現，一般要求，我們儘量的malloc之後，呼叫free。但是總會有忘記free的時候啊。一般可以有如下幾種方式來避免記憶體洩露：

1）  使用智慧指標，這個在C++中較為常見；

2）  使用記憶體池；

3）  自己封裝一層malloc/free等等。當申請記憶體時，將申請資訊放入到一個已分配記憶體資訊連結串列裡面。free時，刪除對應的資訊表的節點。在程式執行結束前，掃瞄該資訊表，若還存在資訊節點，那麼該節點記錄的就是洩露的記憶體資訊。若連結串列為空，那就是說沒有發生記憶體洩露；

4）使用檢測工具檢測記憶體洩露，進而修補程式，這樣的工具有比如Valgrind等等。

以下，給出一個按方式3實現的記憶體洩露檢測的實現版本，程式碼量本身不多。

leak_detector_c.h檔案

 #ifndef  LEAK_DETECTOR_C_H
  #define  LEAK_DETECTOR_C_H
  
  #define  FILE_NAME_LENGTH          256
  #define  OUTPUT_FILE               "/home/leak_info.txt" /*this file should be created first!*/
  #define  malloc(size)               xmalloc (size, __FILE__, __LINE__)
  #define  calloc(elements, size)     xcalloc (elements, size, __FILE__, __LINE__)
  #define  free(mem_ref)              xfree(mem_ref)
  
  struct _MEM_INFO
  {
      void            *address;
      unsigned int    size;
      char            file_name[FILE_NAME_LENGTH];
      unsigned int    line;
  };
  typedef struct _MEM_INFO MEM_INFO;
  
  struct _MEM_LEAK {
      MEM_INFO mem_info;
      struct _MEM_LEAK * next;
  };
  typedef struct _MEM_LEAK MEM_LEAK;
  
  void add(MEM_INFO alloc_info);
  void erase(unsigned pos);
  void clear(void);
  
  void * xmalloc(unsigned int size, const char * file, unsigned int line);
  void * xcalloc(unsigned int elements, unsigned int size, const char * file, unsigned int line);
  void xfree(void * mem_ref);
  
  void add_mem_info (void * mem_ref, unsigned int size,  const char * file, unsigned int line);
  void remove_mem_info (void * mem_ref);
  void report_mem_leak(void);
  
 #endif
 

leak_detector_c.c檔案

#include    <stdio.h>
#include    <malloc.h>
#include    <string.h>
#include    "leak_detector_c.h"
 
#undef      malloc
#undef      calloc
#undef      free
  
  
static MEM_LEAK * ptr_start = NULL;
static MEM_LEAK * ptr_next =  NULL;

/*
* adds allocated memory info. into the list
*
*/
void add(MEM_INFO alloc_info)
{

     MEM_LEAK * mem_leak_info = NULL;
     mem_leak_info = (MEM_LEAK *) malloc (sizeof(MEM_LEAK));
     mem_leak_info->mem_info.address = alloc_info.address;
     mem_leak_info->mem_info.size = alloc_info.size;
     strcpy(mem_leak_info->mem_info.file_name, alloc_info.file_name); 
     mem_leak_info->mem_info.line = alloc_info.line;
     mem_leak_info->next = NULL;
 
    if (ptr_start == NULL)  
    {
        ptr_start = mem_leak_info;
        ptr_next = ptr_start;
    }
    else {
        ptr_next->next = mem_leak_info;
        ptr_next = ptr_next->next;               
    }

}
/*
  * erases memory info. from the list
  *
*/
void erase(unsigned pos)
{
 
     unsigned index = 0;
     MEM_LEAK * alloc_info, * temp;
      
      if(pos == 0)
      {
          MEM_LEAK * temp = ptr_start;
          ptr_start = ptr_start->next;
          free(temp);
      }
      else 
      {
          for(index = 0, alloc_info = ptr_start; index < pos; 
              alloc_info = alloc_info->next, ++index)
          {
              if(pos == index + 1)
              {
                  temp = alloc_info->next;
                  alloc_info->next =  temp->next;
 

                 if(temp->next==NULL)
                  {
                    ptr_next = alloc_info;
                  }
                  free(temp);
                  break;
              }
          }
      }
  }
  
  /*
   * deletes all the elements from the list
   */
  void clear()
  {
      MEM_LEAK * temp = ptr_start;
      MEM_LEAK * alloc_info = ptr_start;
  
      while(alloc_info != NULL) 
      {
          alloc_info = alloc_info->next;
          free(temp);
          temp = alloc_info;
      }

      ptr_start=NULL;
  }
  
  /*
   * replacement of malloc
   */
  void * xmalloc (unsigned int size, const char * file, unsigned int line)
  {
      void * ptr = malloc (size);
      if (ptr != NULL) 
      {
          add_mem_info(ptr, size, file, line);
      }
      return ptr;
  }
  
  /*
   * replacement of calloc
   */
  void * xcalloc (unsigned int elements, unsigned int size, const char * file, unsigned int line)
  {
      unsigned total_size;
      void * ptr = calloc(elements , size);
      if(ptr != NULL)
      {
          total_size = elements * size;
          add_mem_info (ptr, total_size, file, line);
      }
      return ptr;
  }
  
  
  /*
   * replacement of free
   */
  void xfree(void * mem_ref)
  {
      remove_mem_info(mem_ref);
      free(mem_ref);
  }
  
/*
* gets the allocated memory info and adds it to a list
*
*/
  void add_mem_info (void * mem_ref, unsigned int size,  const char * file, unsigned int line)
  {
     MEM_INFO mem_alloc_info;
 
     /* fill up the structure with all info */
     memset( &mem_alloc_info, 0, sizeof ( mem_alloc_info ) );
      mem_alloc_info.address  = mem_ref;
      mem_alloc_info.size = size;
      strncpy(mem_alloc_info.file_name, file, FILE_NAME_LENGTH);
     mem_alloc_info.line = line;
     
     /* add the above info to a list */
      add(mem_alloc_info);
 }
  
  /*
   * if the allocated memory info is part of the list, removes it
  *
  */
 void remove_mem_info (void * mem_ref)
 {
    unsigned short index;
     MEM_LEAK  * leak_info = ptr_start;
 
     /* check if allocate memory is in our list */
    for(index = 0; leak_info != NULL; ++index, leak_info = leak_info->next)
    {
        if ( leak_info->mem_info.address == mem_ref )
        {
             erase ( index );
             break;
        }
    }
}

/*
  * writes all info of the unallocated memory into a file
  */
 void report_mem_leak(void)
{
    unsigned short index;
    MEM_LEAK * leak_info;


    FILE * fp_write = fopen (OUTPUT_FILE, "w+");
    char info[1024];


     if(fp_write != NULL)
     {
         sprintf(info, "%s\r\n", "Memory Leak Summary");
         fwrite(info, (strlen(info)) , 1, fp_write);
         sprintf(info, "%s\r\n", "-----------------------------------");
         fwrite(info, (strlen(info)) , 1, fp_write);


        for(leak_info = ptr_start; leak_info != NULL; leak_info = leak_info->next)
        {
             sprintf(info, "address : %d\r\n", leak_info->mem_info.address);
             fwrite(info, (strlen(info)) , 1, fp_write);
             sprintf(info, "size    : %d bytes\r\n", leak_info->mem_info.size);
             fwrite(info, (strlen(info)) , 1, fp_write);
             sprintf(info, "file    : %s\r\n", leak_info->mem_info.file_name);
             fwrite(info, (strlen(info)) , 1, fp_write);
             sprintf(info, "line    : %d\r\n", leak_info->mem_info.line);
             fwrite(info, (strlen(info)) , 1, fp_write);
             sprintf(info, "%s\r\n", "-----------------------------------");
             fwrite(info, (strlen(info)) , 1, fp_write);


             printf("addr=%d,size=%d,file=%s,line=%d\n"
                ,leak_info->mem_info.address
                ,leak_info->mem_info.size
                ,leak_info->mem_info.file_name
                ,leak_info->mem_info.line);
        }


        fclose(fp_write);
      }
      else
      {


      }
      /*clear();*/
}

使用時，只需將以上兩個檔案放入到你的工程目錄下，並在主函式裡面呼叫report_mem_leak就OK了。

測試test.c檔案

#include    "leak_detector_c.h"
int main()
{
    char * ptr1 = (char *)malloc(10);
    int * ptr2 = (int *)calloc(10, sizeof(int));
    float * ptr3 = (float *) calloc(15, sizeof(float));
    free(ptr2);
atexit(report_mem_leak);
return 0;
}

編譯test.c並執行，可以在/home/leak_info.txt檔案中，看到兩條記憶體洩露記錄。

總的來說，這樣的檢測方式還是有一定效果的，但是同時記憶體資訊連結串列節點也使用了malloc來申請記憶體，這就造成了一定的額外的記憶體開銷。

我覺得要避免記憶體洩露，首先是自身要養成良好的程式設計習慣，然後是使用相關的方法和工具對程式碼進行檢測，最後是要閱讀程式碼了。工具也並不能檢測出所有的記憶體洩露，在這個時候只能靠自己去閱讀程式碼分析程式碼了，人畢竟比機器靈活嘛！

./autogen.sh


./configure --host=powerpc-linux CC=powerpc-linux-gnu-gcc CPP=powerpc-linux-gnu-cpp CXX=powerpc-linux-gnu-g++ --prefix=/mnt/nand


make

make install

 ./valgrind --tool=memcheck --vgdb=no ./memleak 

注意：

1. --prefix=/mnt/nand 指定的目錄要與開發板上放置的目錄一致

2. 引數必須 --vgdb=no 否則會如下錯誤（可能因為我嵌入式linux 沒有整合gdb)

[email protected]:/mnt/nand/bin# ./valgrind --tool=memcheck ./memleak 
==1300== Memcheck, a memory error detector
==1300== Copyright (C) 2002-2013, and GNU GPL'd, by Julian Seward et al.
==1300== Using Valgrind-3.9.0 and LibVEX; rerun with -h for copyright info
==1300== Command: ./memleak
==1300== 
==1300== error 2 No such file or directory
==1300== mknod /tmp/vgdb-pipe-from-vgdb-to-1300-by-root-on-/bin/hostname
==1300== valgrind: fatal error: vgdb FIFOs cannot be created.