Memory leaks and common solutions

Hello everyone , I meet you again , I'm the king of the whole stack , I wish every programmer can learn more languages .

   The reason for writing this article is that I spent a lot of energy on the mature code some time ago memory leak problem . The purpose of writing this is to hope that we should develop good coding habits , Try to avoid this problem , Because when you deal with such problems in front of a large piece of code , No doubt add at this time � The cost and difficulty of solving . To be exact, it is a remedial measure .

Copy

1.  What is memory leak （memory leak）？

Copy

  It refers to the situation that the program fails to release the memory that is no longer used due to negligence or error . A memory leak is not a physical loss of memory , But after the application allocates some memory , Because of design mistakes , Lost control of this segment of memory , So it's a waste of memory . 

Copy

A memory leak is a particular type of unintentional memory consumption by a computer program where the program fails to release memory when no longer needed. This condition is normally the result of a bug in a program that prevents it from freeing up memory that it no longer needs.This term has the potential to be confusing, since memory is not physically lost from the computer. Rather, memory is allocated to a program, and that program subsequently loses the ability to access it due to program logic flaws.

2.  about C and C++ No such thing Garbage Collection  In terms of language , We focus on two types of memory leaks ：

Copy

Heap memory leak （Heap leak）. Memory allocation refers to the basis for the execution of the program malloc,realloc new Wait for a piece of memory allocated from the heap , After that, you must call the corresponding free perhaps delete Delete . Suppose the design error of the program causes this part of memory not to be released , Then this memory will not be used after that , It will produce Heap Leak.

   System resource leakage （Resource Leak）. It mainly refers to that the program uses the resources allocated by the system  Bitmap,handle ,SOCKET Wait until the corresponding function is not used , Leading to a waste of system resources , Serious can lead to reduced system performance , The system execution is unstable .  

Copy

3.  How to solve memory leak ？

Copy

 The difficulty of memory leakage lies in 1. The compiler cannot find these problems .2. These errors can only be caught during execution , These errors have no obvious symptoms , Now is now, now is now .3. For terminal development users such as mobile phones , Especially difficult . Here are three ways to solve memory leaks ：

Copy

 First of all , Good coding habits , Try to use memory in program segments , Memory leak detected . When the program is stable , When checking for memory leaks , Undoubtedly add � The difficulty and complexity of elimination .

Copy

 Using memory allocation functions , Remember to use the function you want to use to release , Once used .

Copy

Heap memory：

Copy

malloc\realloc ------  free

Copy

new \new[] ----------  delete \delete[]

Copy

GlobalAlloc------------GlobalFree 

Copy

 Pay special attention to memory leaks of array objects 

Copy

     MyPointEX *pointArray =new MyPointEX [100];

Copy

       Its deletion form is ：

Copy

     delete []pointArray 

Copy

Resource Leak : Look carefully at the usage of system resources before using , Prevent misuse or forgetting to release system resources .

Copy

 Let's see MSDN Last example of creating a font ：

Copy

 RECT rect;

Copy

HBRUSH hBrush;

Copy

FONT hFont;

Copy

hdc = BeginPaint(hWnd, &ps);

Copy

 hFont = reateFont(48,0,0,0,FW_DONTCARE,FALSE,TRUE,FALSE,DEFAULT_CHARSET,OUT_OUTLINE_PRECIS, CLIP_DEFAULT_PRECIS,CLEARTYPE_QUALITY, VARIABLE_PITCH,TEXT("Impact"));

Copy

SelectObject(hdc, hFont); 

Copy

SetRect(&rect, 100,100,700,200);

Copy

SetTextColor(hdc, RGB(255,0,0));

Copy

DrawText(hdc, TEXT(“Drawing Text with Impact”), -1,&rect, DT_NOCLIP);

DeleteObject(hFont);  

Copy

 EndPaint(hWnd, &ps);

Copy

 Suppose you forget to release the font after using , This leads to resource leakage . 

Copy

    Pay particular attention to system objects based on reference counting , Because only its reference count is 0 when , The object can be deleted correctly . And there are new system resources generated during its use , After use , Suppose it is not deleted in time , Will affect its reference count .

Copy

 IDNS *m_pDns//define a DNS object.

Copy

   If(NULL == m_pDns)

Copy

{  

Copy

   IEnv_CreateInstance (m_pEnv,AEECLSID_DNS,(void **) (&m_pDns))

Copy

}

 If(m_pDns)

Copy

{

Copy

Char szbuff[256];

IDNS_AddQuestions(M_pDns,AEEDNSTYPE_A,ADDDNSCLASS_IN,szbuff);

IDNS_Start(m_pDns,this);

const AEEDNSResponse * pDnsResponse = NULL;

IDNS_GetResponse(pMe->m_pDns, &pDnsResponse);

…………………………………………………………

Copy

…………………………………………………………..

………………………………………………………..

}

DNS_Release(pMe->m_pDns);// When the program is executed to this point , Its return value is not 0, yes 1, It means that the program has generated a memory leak , The system already has a DNS The generated kernel object is not released , And when this code is executed many times , Memory leaks will continue to add �……..

Copy

m_pDns=NULL;

}

 It doesn't look very intuitive , Careful analysis will find , object pDnsResponse It's from m_pDns Generate new object, therefore m_pDns The reference count of will be added �, So after using pDnsResponse, should release  This object returns its reference count to normal .

Copy

 For resource , You can also use RAII,RAII(Resource acquisition is initialization) Resource acquisition is initialization , It is a very easy Technology , utilize C++ The concept of object lifecycle to control program resources , For example, memory. , File handle , Network connection and audit trail (audit trail) etc. .RAII The basic technical principle of is very easy. If you want to keep track of an important resource , So create an object , And associate the life cycle of resources with the life cycle of objects . In this way , Can use C++ Sophisticated object management facilities to manage resources .( It's still in good condition ) 

Copy

 example 2: 

Copy

Struct ITypeface *pTypeface;

Copy

if (pTypeface)

Copy

{

Copy

IANY_CreateInstance(g_pApplet->m_pIShell,AEECLSID_BTFETypeface,void**)& Typeface);

Copy

} 

Copy

 Next, we can create fonts from this interface , example 

Copy

IHFont **pihf=NULL;

Copy

   ITypeface_NewFontFromFile(ITypeface,……,&pihf).

Copy

   ITypeface_NewFontFrommemory(ITypeface,……..,&pihf)

Copy

   ITypeface_NewFontFromClassID(IType,……,&pihf)

Copy

    But remember , These fonts must be release fall , Otherwise, in the end  iTypeface The reference count of is the number of fonts you didn't delete at last . 

Copy

 second , heavy load   new  and  delete. This is also a common method in the coding process .

Copy

 The following is a simple sample To illustrate .

Copy

memchecker.h

Copy

structMemIns

Copy

{

Copy

    void * pMem;

Copy

    int m_nSize;

Copy

    char m_szFileName[256];

Copy

    int m_nLine;

Copy

    MemIns * pNext;

Copy

};

Copy

classMemManager

Copy

{

Copy

public:

Copy

    MemManager();

Copy

    ~MemManager();

Copy

private:

Copy

    MemIns *m_pMemInsHead;

Copy

    int m_nTotal;

Copy

public:

Copy

    static MemManager* GetInstance();

Copy

    void Append(MemIns *pMemIns);

Copy

    void Remove(void *ptr);

Copy

    void Dump(); 

Copy

};

Copy

void *operatornew(size_tsize,constchar*szFile, int nLine);

Copy

void operatordelete(void*ptr,constchar*szFile, int nLine);

Copy

 void operatordelete(void*ptr);

Copy

void*operatornew[] (size_tsize,constchar*szFile,int nLine);

Copy

void operatordelete[](void*ptr,constchar*szFile, int nLine);

Copy

void operatordelete[](void *ptr);

Copy

memechecker.cpp

Copy

#include"Memchecher.h"

Copy

#include<stdio.h>

Copy

#include<malloc.h>

Copy

#include<string.h>

Copy

MemManager::MemManager()

Copy

{

Copy

    m_pMemInsHead=NULL;

Copy

    m_nTotal=NULL;

Copy

}

Copy

MemManager::~MemManager()

Copy

{

Copy

}

Copy

voidMemManager::Append(MemIns *pMemIns)

Copy

{

Copy

    pMemIns->pNext=m_pMemInsHead;

Copy

    m_pMemInsHead = pMemIns;

Copy

    m_nTotal+= m_pMemInsHead->m_nSize;

Copy

}

Copy

voidMemManager::Remove(void *ptr)

Copy

{

Copy

    MemIns * pCur = m_pMemInsHead;

Copy

    MemIns * pPrev = NULL;

Copy

    while(pCur)

Copy

    {

Copy

        if(pCur->pMem ==ptr)

Copy

        {

Copy

           if(pPrev)

Copy

            {

Copy

               pPrev->pNext =pCur->pNext;

Copy

            }

Copy

           else

Copy

            {

Copy

               m_pMemInsHead =pCur->pNext;

Copy

            }

Copy

           m_nTotal-=pCur->m_nSize;

Copy

           free(pCur);

Copy

           break;

Copy

        }

Copy

        pPrev = pCur;

Copy

        pCur = pCur->pNext;

Copy

    }

Copy

}

Copy

voidMemManager::Dump()

Copy

{

Copy

    MemIns * pp = m_pMemInsHead;

Copy

    while(pp)

Copy

    {

Copy

        printf( "File is %s\n", pp->m_szFileName );

Copy

        printf( "Size is %d\n", pp->m_nSize );

Copy

        printf( "Line is %d\n", pp->m_nLine );

Copy

        pp = pp->pNext;

Copy

    }

Copy

}

Copy

Copy

voidPutEntry(void *ptr,intsize,constchar*szFile, int nLine)

Copy

{

Copy

    MemIns * p = (MemIns *)(malloc(sizeof(MemIns)));

Copy

    if(p)

Copy

    {

Copy

        strcpy(p->m_szFileName,szFile);

Copy

        p->m_nLine = nLine;

Copy

        p->pMem = ptr;

Copy

        p->m_nSize = size;

Copy

        MemManager::GetInstance()->Append(p);

Copy

    }

Copy

}

Copy

voidRemoveEntry(void *ptr)

Copy

{

Copy

    MemManager::GetInstance()->Remove(ptr);

Copy

}

Copy

void *operatornew(size_tsize,constchar*szFile, int nLine)

Copy

{

Copy

    void * ptr = malloc(size);

Copy

    PutEntry(ptr,size,szFile,nLine);

Copy

    return ptr;

Copy

}

Copy

voidoperatordelete(void *ptr)

Copy

{

Copy

    RemoveEntry(ptr);

Copy

    free(ptr);

Copy

}

Copy

void operatordelete(void*ptr,constchar * file, intline)

Copy

{

Copy

    RemoveEntry(ptr);

Copy

    free(ptr);

Copy

}

Copy

void*operatornew[] (size_tsize,constchar* szFile,intnLine)

Copy

{

Copy

    void * ptr = malloc(size);

Copy

    PutEntry(ptr,size,szFile,nLine);

Copy

    return ptr;

Copy

}

Copy

void operatordelete[](void *ptr)

Copy

{

Copy

    RemoveEntry(ptr);

Copy

    free(ptr);

Copy

}

Copy

void operatordelete[](void*ptr,constchar*szFile,intnLine)

Copy

{

RemoveEntry(ptr);

    free(ptr);

Copy

}

Copy

#definenewnew(__FILE__,__LINE__)

Copy

MemManagerm_memTracer;

Copy

MemManager*MemManager::GetInstance()

Copy

{

Copy

    return &m_memTracer;

Copy

} 

Copy

void main()

Copy

{

    int *plen =newint ;

Copy

    *plen=10;

Copy

    delete plen;

Copy

    char *pstr=newchar[35];

Copy

    strcpy(pstr,"hello memory leak");

Copy

    m_memTracer.Dump();

Copy

    return ;

Copy

}

Copy

  The main idea is to manage the allocated memory in the form of a linked list , Delete from the linked list after use , At the end of the program can check to change the list , It records the files with memory leaks , The number of lines in the file and the size of the leak .

Copy

 Third ,Boost  Medium smart pointer（ To be in good condition , Combined with your suggestions ）

Copy

 Fourth , Some common tool plug-ins , See my Blog Related articles in .

Copy

4.  Memory leakage leads to the topic of memory overflow ：

Copy

 The so-called memory overflow is that the memory you require to allocate exceeds what the system can give you , The system can't meet the demand , Then there will be a memory overflow problem .

Copy

 Common overflows mainly include ：

Copy

 Memory allocation failed , It was used .
 The solution often used is , Check that the pointer is... Before using memory NULL. Hypothetical pointer p  Is the parameter of the function , Then use... At the entry of the function assert(p!=NULL) Inspection . Let's assume that malloc  or new  To apply for memory , Should use the if(p==NULL) or if(p!=NULL) Do error proofing .

Copy

 Memory allocation was successful , But reference it before initialization .
 Memory allocation successful and initialized , But operations cross the boundaries of memory .
 For example, subscripts often occur when using arrays “ many 1” perhaps “ Less 1” The operation of . Especially in for  In loop statement , The number of cycles is very easy mistake , Causes array operations to be out of bounds .

Copy

 Use free  or delete  After releasing memory , The pointer is not set to NULL. Cause to produce “ Wild pointer ”.

Copy

 The object calling relationship in the program is too complex , It's really difficult to figure out whether an object has released memory , At this time, the data structure should be designed again , Fundamentally solve the confusion of object management .（ But I feel it deeply , ha-ha ）

Copy

 Don't forget to initialize arrays and dynamic memory . Prevent uninitialized memory from being used as a right value .

Copy

Publisher ： Full stack programmer stack length , Reprint please indicate the source ：https://javaforall.cn/118606.html Link to the original text ：https://javaforall.cn