Hvor du kan sette gratis i et C -program
Hvor du kan sette gratis () i et C -program?
Ved hjelp av gratis() Å dele ut dynamisk minne er en kritisk del av å skrive et godt strukturert C-program. Å gjøre det kan forhindre vanlige minnelaterte problemer som segmenteringsfeil, hukommelseslekkasjer og hukommelsesfragmentering. Siden programmets drift avhenger av tildeling og omlokasjon av riktig størrelse minneblokker til riktig tid, er det viktig å bruke gratis() funksjon på en passende måte. Hvis minnet ikke blir gitt ut riktig, kan det føre til at minnet blir fanget, og dermed får programmet til å ikke kjøre som forventet.
Det er flere steder hvor du kan stille inn gratis() i et C -program og detaljene er diskutert nedenfor.
1: Slutt på et C -program
De gratis() Funksjon kan plasseres på slutten av et C -program, etter at allokering av minne er ferdige. Dette sikrer at minnet blir behandlet når programmet er fullført, og at det ikke oppstår noen minnelekkrelaterte problemer. Videre gratis() Funksjon bør være til stede når programmet går ut, slik at det kan få minnet fra tildelte minneblokker, og dermed frigjøre minneområdet.
#inkludere
#inkludere
int main ()
int *ptr1;
int n = 6;
ptr1 = (int *) malloc (n * sizeof (int));
if (ptr1 == null)
printf ("Feil: minnetildeling mislyktes \ n");
Avslutt (1);
for (int i = 0; i < n; i++)
*(ptr1 + i) = i;
printf ("%d", *(ptr1 + i));
gratis (ptr1);
retur 0;
I koden ovenfor bruker vi først Malloc () for å tildele minne, hvoretter vi bruker det til å lagre noen tall. Vi bruker gratis() Funksjon for å få minnet på slutten av programmet.
Produksjon
Hvis gratis() Funksjon brukes ikke når programmet går ut av, da kan uforutsigbare resultater oppstå, for eksempel at programmet mister dataene, krasjer eller kjører for sakte på grunn av fanget minne. Som sådan er det viktig å strategisk plassere gratis() funksjon deretter.
2: Før slutten av løkken
Endelig er det beste praksis å plassere gratis() Funksjon før slutten av en sløyfe for å kunne håndtere minne før sløyfen kjøres igjen. Ved å gjøre dette, er ikke programmet belastet med oppgaven å gjentatte ganger tildele og håndtere minne i en loopet del av koden.
#inkludere
#inkludere
int main ()
int *ptr;
int n = 4;
for (int i = 0; i < n; i++)
ptr = (int*) malloc (størrelse av (int));
if (ptr == null)
printf ("Feil: minnetildeling ikke vellykket \ n");
Avslutt (1);
*ptr = i;
printf ("%d", *ptr);
gratis (PTR);
retur 0;
I eksemplet ovenfor bruker vi Malloc () Funksjon inne i løkken for å tildele minne, som deretter brukes til å lagre et enkelt heltall. Vi ringer gratis() For å bryte minnet på slutten av hver iterasjon av loopen. Dette forhindrer potensielle minnelekkasjer som ville oppstå hvis minnet ikke ble omhandlet ved avslutningen av programmet og garanterer at det er tilgjengelig for påfølgende deler av programmet.
Produksjon
Merk: Det er avgjørende å huske at du ikke bør gi ut dynamisk tildelt minne inne i en sløyfe hvis du trenger å bruke det utenfor den. Minnet bør deretter frigjøres når du er ferdig med å bruke det.
3: I tilfelle feil
Til slutt bør det utvises forsiktighet for å sikre at ethvert minne som er tildelt i et program blir utgitt når programmet avsluttes, selv om en uventet feil oppstår. Hvis det oppstår en feil, bør det tas spesiell forsiktig.
#inkludere
#inkludere
int main ()
int *ptr1, *ptr2;
ptr1 = (int*) malloc (sizeof (int));
if (ptr1 == null)
printf ("Feil: minnetildeling ikke vellykket \ n");
Avslutt (1);
ptr2 = (int *) malloc (3 * sizeof (int));
if (ptr2 == null)
printf ("Feil: minnetildeling ikke vellykket \ n");
gratis (ptr1);
Avslutt (1);
gratis (ptr1);
gratis (ptr2);
retur 0;
I dette eksemplet tildeles minnet ved bruk av Malloc (), Og etter hver tildeling blir feil kontrollert. Vi bruker gratis() For å frigjøre ethvert minne som tidligere ble tildelt hvis det oppstår en feil før du stenger av søknaden. For å forhindre lekkasjer.
Produksjon
4: I samme blokk der minnet ble tildelt
For å sikre at minnet blir utgitt på en riktig måte, bør eventuelle kodeblokker som benytter seg av dynamiske minnetildelinger utformes for å frigjøre minnet så snart det ikke lenger er nødvendig. Dette betyr at hvis minnet er tildelt i en spesifikk kodeblokk, så en samtale til gratis() bør også plasseres i den samme kodeblokken for å sikre at eventuelle matriser, strenger eller andre datastrukturer som ikke lenger er nødvendig, blir gitt ut tilbake til systemet.
#inkludere
#inkludere
int main ()
int n = 5;
int *ptr = (int *) malloc (n *sizeof (int));
if (ptr == null)
printf ("Feil: minnetildeling ikke vellykket \ n");
Avslutt (1);
for (int i = 0; i < n; i++)
*(ptr + i) = i;
printf ("%d", *(ptr + i));
gratis (PTR);
retur 0;
Eksemplet ovenfor bruker en kodeblokk for å tildele minne ved hjelp av Malloc () funksjon, som deretter brukes til å lagre en rekke tall. Ved hjelp av gratis(), Vi slipper deretter minnet etter blokkens konklusjon. Vi klarer ikke å bruke eller frigjøre minnet utenfor blokken siden det bare er gyldig innenfor blokkenes rammer.
Produksjon
Merk: Husk å bare bruke gratis() på minnet som er blitt tildelt dynamisk, for eksempel å bruke Malloc (), Calloc (), eller realloc (). En segmenteringsfeil eller andre problemer kan oppstå hvis du prøver å frigjøre minne som ikke er blitt tildelt dynamisk siden oppførselen til søknaden din er ukjent i dette tilfellet.
Siste tanker
De gratis() Funksjonen skal plasseres nøye i et C-program for å sikre at programmet kjører effektivt og at det ikke oppstår noen minnelekkrelaterte problemer. Dette innebærer å bruke gratis() Funksjon på slutten av programmet, i samme blokk der minnet ble tildelt, og før slutten av en looped del av koden. Det bør også utvises forsiktig. Ved å bruke riktig gratis() Funksjon, et C -program kan bruke ressurser på riktig måte, redusere hukommelsesfragmentering og minnelekkasjer og kjøre som forventet.