Dünaamiline mälu eraldamine funktsioonides C: malloc (), calloc ()

Lang L: none (table-of-contents):

Anonim

Enne C-dünaamilise mälu jaotamise õppimist mõistame järgmist:

Kuidas mäluhaldus C-s töötab?

Kui deklareerite muutuja põhi andmetüübi abil, eraldab C kompilaator muutuja jaoks mäluruumi automaatselt, mida nimetatakse virnaks .

Näiteks ujukmuutuja võtab deklareerimisel tavaliselt 4 baiti (vastavalt platvormile). Seda teavet saame kontrollida operaatori suuruse abil, nagu on näidatud allpool toodud näites

#include int main() { float x; printf("The size of float is %d bytes", sizeof(x)); return 0;}

Väljundiks on:

 The size of float is 4 bytes

Samuti eraldatakse külgnevatesse mäluplokkidesse määratud suurusega massiiv, igal plokil on ühe elemendi suurus:

#include int main() { float arr[10];printf("The size of the float array with 10 element is %d", sizeof(arr)); return 0;}

Tulemuseks on:

 The size of the float array with 10 element is 40

Nagu seni teada sai, hallatakse põhi andmetüübi või massiivi deklareerimisel mälu automaatselt. C-s on aga mälu eraldamise protsess, mis võimaldab teil rakendada programmi, milles massiivi suurus on määramata, kuni käivitate oma programmi (käituse). Seda protsessi nimetatakse " dünaamiliseks mälu jaotamiseks ".

Selles õpetuses saate teada

  • Kuidas mäluhaldus C-s töötab?
  • Dünaamiline mälu eraldamine C-s
  • C malloc () Funktsioon
  • Funktsioon vaba ()
  • C calloc () Funktsioon
  • calloc () vs malloc (): peamised erinevused
  • C realloc () Funktsioon
  • Dünaamilised massiivid

Dünaamiline mälu eraldamine C-s

Dünaamiline mälu eraldamine on käsitsi eraldamine ja mälu vabastamine vastavalt teie programmeerimisvajadustele. Dünaamilist mälu hallatakse ja serveeritakse osutitega, mis osutavad äsja eraldatud mäluruumile piirkonnas, mida kutsume kuhjaks.

Nüüd saate ilma probleemideta käivitamise ajal dünaamiliselt luua ja hävitada hulga elemente. Kokkuvõtteks võib öelda, et automaatne mäluhaldus kasutab virna ja C-dünaamiline mälujaotus kuhja.

teegil on funktsioonid, mis vastutavad dünaamilise mäluhalduse eest.

Funktsioon Eesmärk
malloc () Eraldab soovitud suurusega mälu ja viib kursori eraldatud ruumi esimesse baitini.
calloc () Eraldab ruumi massiivi elementidele. Algatab elemendid nulli ja tagastab kursori mällu.
realloc () Seda kasutatakse varem eraldatud mäluruumi suuruse muutmiseks.
Tasuta () Vabastab või tühjendab varem eraldatud mäluruumi.

Arutame ülaltoodud funktsioone nende rakendusega

C malloc () Funktsioon

Funktsioon C malloc () tähistab mälu eraldamist. See on funktsioon, mida kasutatakse mäluploki dünaamiliseks eraldamiseks. See reserveerib määratud suurusega mäluruumi ja tagastab nullkoha, mis osutab mälukohale. Tagastatud kursor on tavaliselt tühine. See tähendab, et saame määrata C malloc () funktsiooni igale osutile.

Malloci süntaks () Funktsioon:

ptr = (cast_type *) malloc (byte_size);

Siin,

  • ptr on cast_type'i osuti.
  • Funktsioon C malloc () tagastab kursori byte_size eraldatud mällu.

Malloc () näide:

Example: ptr = (int *) malloc (50)

Kui see lause on edukalt täidetud, reserveeritakse 50 baiti mäluruum. Reserveeritud ruumi esimese baidi aadress määratakse kursori ptr tüübile int.

Mõelge veel ühele näitele:

#include int main(){int *ptr;ptr = malloc(15 * sizeof(*ptr)); /* a block of 15 integers */if (ptr != NULL) {*(ptr + 5) = 480; /* assign 480 to sixth integer */printf("Value of the 6th integer is %d",*(ptr + 5));}}

Väljund:

Value of the 6th integer is 480

  1. Pange tähele, et sizeof ( int) asemel kasutati sizeof (* ptr) , et muuta kood kindlamaks, kui * ptr-deklaratsioon hiljem sisestatakse teisele andmetüübile.
  2. Jaotus võib ebaõnnestuda, kui mälu pole piisavalt. Sellisel juhul tagastab NULL kursori. NULL-kursori kontrollimiseks peaksite lisama koodi.
  3. Pidage meeles, et eraldatud mälu on külgnev ja seda saab käsitleda massiivina. Massiivielementidele juurdepääsemiseks võime kasutada osuti aritmeetikat, mitte sulgudes []. Massiivielementidele viitamiseks soovitame kasutada klahvi +, kuna juurdekasvu ++ või + = kasutamine muudab kursori salvestatud aadressi.

Funktsiooni Malloc () saab kasutada ka nii andmetüübi kui ka keerukate andmetüüpide, näiteks struktuuride puhul.

Funktsioon vaba ()

Muutujate mälu jaotatakse kompileerimise ajal automaatselt. Dünaamilise mälu jaotamise korral peate mälu selgesõnaliselt lahendama. Kui seda pole tehtud, võib ilmneda mäluviga.

Funktsiooni free () nimetatakse mälu vabastamiseks / jagamiseks C. Vabastades oma programmis mälu, muudate selle hiljem kasutamiseks kättesaadavaks.

Näiteks:

#include int main() {int* ptr = malloc(10 * sizeof(*ptr));if (ptr != NULL){*(ptr + 2) = 50;printf("Value of the 2nd integer is %d",*(ptr + 2));}free(ptr);}

Väljund

 Value of the 2nd integer is 50

C calloc () Funktsioon

Funktsioon C calloc () tähistab külgnevat jaotust. Seda funktsiooni kasutatakse mitme mäluploki eraldamiseks. See on dünaamiline mälu eraldamise funktsioon, mida kasutatakse mälu eraldamiseks keerukatele andmestruktuuridele, nagu massiivid ja struktuurid.

Funktsiooni Malloc () kasutatakse ühe mäluruumiploki eraldamiseks, C-s asuvat calloc () aga mitme mäluploki eraldamiseks. Iga funktsiooni calloc () eraldatud plokk on sama suur.

Funktsiooni calloc () süntaks:

ptr = (cast_type *) calloc (n, size);
  • Ülaltoodud lauset kasutatakse n sama suurusega mäluploki eraldamiseks.
  • Pärast mäluruumi eraldamist lähtestatakse kõik baidid nulli.
  • Tagastatakse kursor, mis asub eraldatud mäluruumi esimesel baidil.

Kui mäluruumi eraldamisel ilmneb viga, näiteks mälupuudus, tagastatakse nullkursor.

Calloc () näide:

Allpool olev programm arvutab aritmeetilise jada summa.

#include int main() {int i, * ptr, sum = 0;ptr = calloc(10, sizeof(int));if (ptr == NULL) {printf("Error! memory not allocated.");exit(0);}printf("Building and calculating the sequence sum of the first 10 terms \ n ");for (i = 0; i < 10; ++i) { * (ptr + i) = i;sum += * (ptr + i);}printf("Sum = %d", sum);free(ptr);return 0;}

Tulemus:

Building and calculating the sequence sum of the first 10 termsSum = 45

calloc () vs malloc (): peamised erinevused

Järgnev on peamine erinevus malloc () Vs calloc () vahel:

Funktsioon calloc () on üldiselt sobivam ja tõhusam kui malloc () funktsioon. Kuigi mõlemat funktsiooni kasutatakse mäluruumi eraldamiseks, saab calloc () korraga eraldada mitu plokki. Te ei pea iga kord mäluplokki taotlema. Funktsiooni calloc () kasutatakse keerukates andmestruktuurides, mis nõuavad suuremat mäluruumi.

C-s calloc () poolt eraldatud mäluplokk lähtestatakse alati nulli, samas kui funktsiooni malloc () C-s sisaldab see alati prügiväärtust.

C realloc () Funktsioon

Funktsiooni C realloc () abil saate juba eraldatud mällu lisada rohkem mälumahtu. See laiendab praegust plokki, jättes algse sisu selliseks, nagu see on. realloc () tähistab C-d mälu ümberjaotamist.

realloc () saab kasutada ka varem eraldatud mälu suuruse vähendamiseks.

Funktsiooni realloc () süntaks:

ptr = realloc (ptr,newsize);

Ülaltoodud lause eraldab muutuja newsize uue kindla suurusega mäluruumi. Pärast funktsiooni täitmist tagastatakse kursor mäluploki esimesse baiti. Uus suurus võib olla suurem või väiksem kui eelmine mälu. Me ei saa olla kindlad, kas äsja eraldatud plokk osutab samale asukohale kui eelmine mäluplokk. See funktsioon kopeerib kõik varasemad andmed uues piirkonnas. See tagab, et andmed jäävad ohutuks.

Realloc () näide:

#include int main () {char *ptr;ptr = (char *) malloc(10);strcpy(ptr, "Programming");printf(" %s, Address = %u\n", ptr, ptr);ptr = (char *) realloc(ptr, 20); //ptr is reallocated with new sizestrcat(ptr, " In 'C'");printf(" %s, Address = %u\n", ptr, ptr);free(ptr);return 0;}

Kui realloc () C-s põhjustab ebaõnnestunud toimingu, tagastab see nullkursori ja ka eelmised andmed vabastatakse.

Dünaamilised massiivid C-s

Dünaamiline massiiv C-s võimaldab elementide arvul vastavalt vajadusele kasvada. C dünaamilist massiivi kasutatakse arvutiteaduse algoritmides laialdaselt.

Järgmises programmis oleme loonud C-s dünaamilise massiivi ja muutnud selle suurust

#include int main() {int * arr_dynamic = NULL;int elements = 2, i;arr_dynamic = calloc(elements, sizeof(int)); //Array with 2 integer blocksfor (i = 0; i < elements; i++) arr_dynamic[i] = i;for (i = 0; i < elements; i++) printf("arr_dynamic[%d]=%d\n", i, arr_dynamic[i]);elements = 4;arr_dynamic = realloc(arr_dynamic, elements * sizeof(int)); //reallocate 4 elementsprintf("After realloc\n");for (i = 2; i < elements; i++) arr_dynamic[i] = i;for (i = 0; i < elements; i++) printf("arr_dynamic[%d]=%d\n", i, arr_dynamic[i]);free(arr_dynamic);}

C Dynamic array programmi tulemus ekraanil:

arr_dynamic[0]=0arr_dynamic[1]=1After reallocarr_dynamic[0]=0arr_dynamic[1]=1arr_dynamic[2]=2arr_dynamic[3]=3

Kokkuvõte

  • Saame mälu dünaamiliselt hallata, luues kuhjaga mäluplokke
  • C-dünaamilises mälu jaotuses eraldatakse mälu töötamise ajal.
  • Dünaamiline mälujaotus võimaldab kasutada paindlikke stringe ja massiive, mida saab programmis igal ajal muuta.
  • See on nõutav, kui teil pole aimugi, kui palju mälu konkreetne struktuur hakkab hõivama.
  • Malloc () C-s on dünaamiline mälu jaotamise funktsioon, mis tähistab mälu jaotamist, mis blokeerib konkreetse suurusega mälu prügiväärtuseks
  • C-s olev Calloc () on külgnev mälu jaotamise funktsioon, mis eraldab mitu mäluplokki initsialiseerituna 0-ni
  • Realloc () C-s kasutatakse mälu ümberjaotamiseks vastavalt määratud suurusele.
  • Dünaamiliselt eraldatud mälu puhastamiseks kasutatakse funktsiooni Free ().