Kailan Nangyayari ang Memory Leak?
Pagkatapos maglaan ng memorya ang software ngunit hindi ito ilalabas pagkatapos nito, mayroong a pagtagas ng memorya . Nangangahulugan ito na ang programa ay patuloy na naglalaan ng higit at higit na memorya para sa mga bagong variable habang iniiwan ang lumang memorya na inilalaan at hindi ginagamit. Nagreresulta ito sa paggamit ng program ng mas maraming memory, at kalaunan, nag-crash ang program dahil sa isang out-of-memory error.
Mga Epekto ng Memory Leak sa C
Tumagas ang memorya maaaring magdulot ng maraming problema sa isang programa. Kung hindi napigilan, a pagtagas ng memorya maaaring maging sanhi ng pag-crash o paghinto ng programa sa pagtakbo, na maaaring humantong sa pagkawala ng data o katiwalian. Bukod dito, dahil ang program ay kumokonsumo ng mas maraming memory kaysa sa kailangan nito, maaari itong makaapekto sa pagganap ng system at maaaring makapagpabagal sa iba pang mga program na tumatakbo sa parehong system.
Paglalaan ng Memorya sa C Language
Ang paglalaan ng memorya ay isinasagawa gamit ang malloc() function sa C Language. Ibinabalik ng pamamaraang ito ang isang sanggunian sa isang bloke ng memorya na may tinukoy na laki. Ang pointer value ay ginagamit para ma-access ang nakalaan na memory block. Kapag hindi na kailangan ang memorya, kailangan itong palayain gamit ang libre() function.
Mga sanhi ng Memory Leaks
Ilan sa mga sanhi ng tumagas ang memorya ay:
1: Maling Pamamahala ng Memorya
Ang pinakamadalas na dahilan ng pagtagas ng memorya ay ang mahinang pamamahala ng memorya sa bahagi ng programmer. Nangyayari ito kapag ang isang programa ay nagpapabaya sa paglabas ng memorya na hindi na kinakailangan.
#include
#include
int pangunahing ( )
{
int * ptr = ( int * ) malloc ( sukat ng ( int ) ) ;
* ptr = 10 ;
printf ( '%d \n ' , * ptr ) ;
ptr = WALA ;
bumalik 0 ;
}
Sa code sa itaas, gamit ang malloc() pamamaraan sa ptr pointer, naglaan kami ng espasyo para sa isang integer memory block. Ang ptr nagbabago ang value ng pointer kapag nagtakda kami WALA dito, ngunit ang memory block na dati nitong tinutukoy ay hindi inilabas. Samakatuwid, a pagtagas ng memorya magreresulta.
Output
2: Out of Scope Pointer
Kapag mayroong variable ng pointer ang saklaw nito, a pagtagas ng memorya nangyayari sa mga programang C.
#include#include
int pangunahing ( )
{
int num1 = 32 , num2 = 23 ;
{
int * sum = ( int * ) malloc ( sukat ng ( int ) ) ;
* sum = num1 + num2 ;
printf ( '%d \n ' , * sum ) ;
}
printf ( '%d \n ' , * sum ) ;
bumalik 0 ;
}
Sa C program sa itaas, ang pangunahing() Ang function ay gumagamit ng isang lokal na saklaw upang maglaan ng isang integer memory block sa sum variable ng pointer. Dahil ginamit namin ang sum pointer upang italaga ang pagdaragdag ng a at b sa bagong nabuong bloke ng memorya, ang bloke ng memorya ay patuloy na inilalaan kahit na matapos ang saklaw ng bloke. Samakatuwid, a pagtagas ng memorya magaganap.
Output
Pag-detect ng Memory Leaks sa C
Pagtuklas at pag-iwas sa tumagas ang memorya ay kritikal sa pagpapanatili ng katatagan at pagganap ng programa. Para ma-detect tumagas ang memorya , ang mga programmer ay maaaring gumamit ng mga tool tulad ng Gate ng halalan , isang memory debugging at tool sa pag-profile. Gate ng halalan tumutulong na matukoy ang mga pagtagas ng memorya sa pamamagitan ng pagsubaybay sa lahat ng mga access sa memorya sa isang programa at pagtukoy kung kailan hindi inilabas ang nakalaan na memorya.
Pag-iwas sa Memory Leak sa C
Iwasan tumagas ang memorya , sundin ang mga tagubilin sa ibaba.
1: Palaging Bitawan ang Inilalaan na Memorya
Dapat palaging hayagang ilabas ang memorya gamit ang libre() pamamaraan pagkatapos na ito ay dynamic na inilalaan gamit ang isang function tulad ng malloc(), calloc(), o realloc() . Sa paggawa nito, tinitiyak na ang memorya ay ibinalik sa system at magagamit para sa iba pang gamit.
2: Pagsubaybay sa Inilalaang Memorya
Ang pagsubaybay sa inilalaan na memorya ay mahalaga upang matiyak na ito ay ilalabas kapag hindi na ito kinakailangan. Ito ay maaaring makamit sa pamamagitan ng pagsubaybay sa bawat memorya na inilaan at pagpapalabas nito kapag hindi na ito kailangan.
3: Subaybayan ang mga Pointer
Dapat na subaybayan ang mga pointer upang awtomatikong pamahalaan ang paglalaan ng memorya at deallocation, na pumipigil sa mga pagtagas ng memorya.
4: Gamitin ang Static Analysis Tools
Sa oras ng pagbuo, maaaring matukoy ng mga static na tool sa pagsusuri ang posible tumagas ang memorya sa mga programang C, gaya ng Clang at GCC. Bago patakbuhin ang application, makakatulong ang mga tool na ito sa paghahanap ng mga posibleng pagtagas ng memorya at paggawa ng mga mungkahi sa pagwawasto.
Ang sumusunod na halimbawa ay naglalarawan sa proseso sa itaas.
#include#include
#include
int pangunahing ( )
{
int * ptr = ( int * ) malloc ( sukat ng ( int ) ) ;
kung ( ptr == WALA ) {
printf ( 'Error sa paglalaan ng memorya. \n ' ) ;
bumalik 1 ;
}
* ptr = 10 ;
printf ( '%d \n ' , * ptr ) ;
libre ( ptr ) ;
bumalik 0 ;
}
Ang code sa itaas na ito ay unang tinutukoy kung ang memory allocation ay matagumpay sa pamamagitan ng pagsuri upang makita kung ang ptr ang sanggunian ay hindi WALA . Maaaring pangasiwaan ng code ang error nang naaangkop kung nabigo ang paglalaan. Kung matagumpay ang paglalaan, binibigyan ng code ang memory block ng halaga ng 10 at naglalabas nito. Pagkatapos nito, ilalabas ng code ang memorya na inilaan sa pamamagitan ng paggamit ng libre() function.
Output
Konklusyon
Tumagas ang memorya maaaring magdulot ng malalaking problema sa mga programa, kabilang ang pagkasira ng pagganap at pag-crash. Ang mga ganitong isyu ay makikilala at maiiwasan sa pamamagitan ng maingat na pamamahala ng memorya, tamang pagsubok, at pagsubaybay sa paggamit ng memorya. Dahil dito, dapat alam ng mga programmer ang potensyal para sa mga pagtagas ng memorya at dapat gawin ang mga kinakailangang hakbang upang maiwasan ang mga ito.