Dinaminis atminties paskirstymas C: malloc (), calloc () funkcijos

Prieš išmokdami C dinaminės atminties paskirstymo, supraskime:

Kaip veikia C atminties valdymas?

Kai deklaruojate kintamąjį naudodami pagrindinį duomenų tipą, C kompiliatorius automatiškai paskirsto atminties vietą kintamajam atminties telkinyje, vadinamame „ stack“ .

Pavyzdžiui, plūduriuojantis kintamasis paprastai deklaruodamas užima 4 baitus (pagal platformą). Mes galime patikrinti šią informaciją naudodami sizeof operatorius, kaip parodyta žemiau, pavyzdžiui

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

Rezultatas bus:

 The size of float is 4 bytes

Taip pat nurodyto dydžio masyvas yra priskiriamas gretimiems atminties blokams, kiekviename bloke yra vieno elemento dydis:

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

Rezultatas:

 The size of the float array with 10 element is 40

Kaip sužinota iki šiol, deklaruojant pagrindinį duomenų tipą ar masyvą, atmintis yra automatiškai valdoma. Tačiau yra atminties paskirstymo C procesas, kuris leis jums įgyvendinti programą, kurioje masyvo dydis nenusprendžiamas, kol paleisite programą (vykdymo laiką). Šis procesas vadinamas „ Dinaminiu atminties paskirstymu “.

Šioje pamokoje sužinosite

  • Kaip veikia C atminties valdymas?
  • Dinaminis atminties paskirstymas C
  • C malloc () Funkcija
  • Laisva () funkcija
  • C calloc () funkcija
  • calloc () vs malloc (): Pagrindiniai skirtumai
  • C realloc () Funkcija
  • Dinaminiai masyvai

Dinaminis atminties paskirstymas C

Dinaminis atminties paskirstymas yra rankinis paskirstymas ir atminties atlaisvinimas pagal jūsų programavimo poreikius. Dinaminė atmintis valdoma ir teikiama rodyklėmis, nukreipiančiomis į naujai priskirtą atminties vietą srityje, kurią mes vadiname kaupu.

Dabar be problemų galite dinamiškai sukurti ir sunaikinti elementų masyvą vykdymo metu. Apibendrinant galima pasakyti, kad automatinis atminties valdymas naudoja rietuvę, o C dinaminės atminties paskirstymas - krūvą.

bibliotekoje yra funkcijos, atsakingos už dinaminį atminties valdymą.

Funkcija Tikslas
malloc () Paskiria reikalaujamo dydžio atmintį ir grąžina žymeklį į pirmąjį paskirtos vietos baitą.
calloc () Skiria vietą masyvo elementams. Inicijuoja elementus į nulį ir grąžina žymeklį į atmintį.
realloc () Jis naudojamas anksčiau paskirstytos atminties dydžiui modifikuoti.
Laisvas() Atlaisvina arba ištuština anksčiau skirtą atminties vietą.

Aptarkime minėtas funkcijas su jų taikymu

C malloc () Funkcija

C malloc () funkcija reiškia atminties paskirstymą. Tai funkcija, naudojama dinamiškai paskirstyti atminties bloką. Tai rezervuoja nurodyto dydžio atminties vietą ir grąžina nulinį rodyklę, nukreipiančią į atminties vietą. Grąžintas žymeklis paprastai yra tuščias. Tai reiškia, kad bet kuriam žymekliui galime priskirti C malloc () funkciją.

Malloc sintaksė () Funkcija:

ptr = (cast_type *) malloc (byte_size);

Čia

  • ptr yra „cast_type“ žymeklis.
  • Funkcija C malloc () grąžina žymeklį į paskirtą „byte_size“ atmintį.

Malloc () pavyzdys:

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

Kai šis sakinys sėkmingai įvykdomas, rezervuojama 50 baitų atminties vieta. Pirmojo rezervuotos vietos baito adresas priskiriamas int tipo žymekliui ptr.

Apsvarstykite kitą pavyzdį:

#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));}}

Išvestis:

Value of the 6th integer is 480

  1. Atkreipkite dėmesį, kad vietoj sizeof (int ) buvo naudojamas sizeof (* ptr), kad kodas būtų patikimesnis, kai vėliau * ptr deklaracija yra surenkama į kitą duomenų tipą.
  2. Priskyrimas gali nepavykti, jei nepakanka atminties. Tokiu atveju jis grąžina NULL žymeklį. Taigi, norėdami patikrinti NULL žymeklį, turėtumėte įtraukti kodą.
  3. Atminkite, kad skirta atmintis yra gretima ir ją galima traktuoti kaip masyvą. Norėdami pasiekti masyvo elementus, galime naudoti žymeklio aritmetiką, o ne skliausteliuose []. Patariame naudoti +, norint nurodyti masyvo elementus, nes naudojant didinimą ++ arba + = keičiamas žymeklio saugomas adresas.

„Malloc“ () funkcija taip pat gali būti naudojama su simbolių duomenų tipu, taip pat su sudėtingais duomenų tipais, tokiais kaip struktūros.

Laisva () funkcija

Kintamųjų atmintis kompiliavimo metu automatiškai paskirstoma. Skiriant dinaminę atmintį, turite aiškiai paskirstyti atmintį. Jei to nepadarysite, gali kilti atminties klaida.

Nemokama () funkcija iškviečiama atlaisvinant / paskirstant atmintį C. Atlaisvindami atmintį savo programoje, vėliau galėsite ją naudoti daugiau.

Pavyzdžiui:

#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);}

Rezultatas

 Value of the 2nd integer is 50

C calloc () funkcija

Funkcija C calloc () reiškia gretimą paskirstymą. Ši funkcija naudojama paskirstyti kelis atminties blokus. Tai yra dinaminė atminties paskirstymo funkcija, naudojama priskirti atmintį sudėtingoms duomenų struktūroms, tokioms kaip masyvai ir struktūros.

Funkcija „Malloc“ () naudojama vienam atminties blokui priskirti, o „Calloc“ (C) - keliems atminties blokams paskirstyti. Kiekvienas calloc () funkcijos paskirtas blokas yra vienodo dydžio.

Funkcijos calloc () sintaksė:

ptr = (cast_type *) calloc (n, size);
  • Ankstesnis teiginys naudojamas n vienodo dydžio atminties blokams priskirti.
  • Paskyrus atminties vietą, visi baitai inicijuojami iki nulio.
  • Grąžinamas žymeklis, kuris šiuo metu yra pirmame paskirtos atminties bate.

Kai įvyksta klaida paskirstant atminties vietą, pvz., Trūksta atminties, grąžinamas nulinis rodyklė.

Calloc () pavyzdys:

Žemiau pateikta programa apskaičiuoja aritmetinės sekos sumą.

#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;}

Rezultatas:

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

calloc () vs malloc (): Pagrindiniai skirtumai

Toliau pateikiamas pagrindinis skirtumas tarp malloc () Vs calloc () C:

Calloc () funkcija paprastai yra tinkamesnė ir efektyvesnė nei malloc () funkcija. Nors abi funkcijos naudojamos atminties paskirstymui, „Calloc“ () vienu metu gali skirti kelis blokus. Kiekvieną kartą nereikia prašyti atminties bloko. Funkcija calloc () naudojama sudėtingose ​​duomenų struktūrose, kurioms reikalinga didesnė atminties vieta.

Atminties blokas, kurį C skiria calloc (), visada inicijuojamas iki nulio, o C funkcijoje malloc () - visada yra šiukšlių vertė.

C realloc () Funkcija

Naudodamiesi funkcija „C realloc ()“ , jau priskirtoje atmintyje galite pridėti daugiau atminties. Išplečia dabartinį bloką, palikdamas originalų turinį tokį, koks jis yra. „realloc“ (C) reiškia atminties perskirstymą.

„realloc“ () taip pat gali būti naudojamas anksčiau paskirstytos atminties dydžiui sumažinti.

Funkcijos „realloc“ () sintaksė:

ptr = realloc (ptr,newsize);

Pirmiau pateiktame sakinyje kintamajame newsize priskiriama nauja atminties vieta su nurodytu dydžiu. Atlikus funkciją, rodyklė bus grąžinta į pirmąjį atminties bloko baitą. Naujas dydis gali būti didesnis arba mažesnis nei ankstesnė atmintis. Mes negalime būti tikri, kad jei naujai paskirtas blokas nurodys tą pačią vietą kaip ir ankstesnis atminties blokas. Ši funkcija nukopijuos visus ankstesnius naujojo regiono duomenis. Tai užtikrina, kad duomenys išliks saugūs.

„Realloc“ () pavyzdys:

#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;}

Kiekvieną kartą, kai C realloc () sukelia nesėkmingą operaciją, jis grąžina nulinį rodyklę ir ankstesni duomenys taip pat atlaisvinami.

Dinaminiai masyvai C

Dinaminis masyvas C leidžia elementų skaičiui augti, jei reikia. C dinaminis masyvas yra plačiai naudojamas informatikos algoritmuose.

Šioje programoje sukūrėme dinaminį masyvo dydį ir pakeitė jo dydį

#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 dinaminio masyvo programos rezultatas ekrane:

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

Santrauka

  • Mes galime dinamiškai valdyti atmintį, prireikus sukurdami atminties blokus
  • C dinaminės atminties paskirstyme atmintis paskirstoma vykdymo metu.
  • Dinaminis atminties paskirstymas leidžia valdyti eilutes ir masyvus, kurių dydis yra lankstus ir gali būti bet kada pakeistas jūsų programoje.
  • Jis reikalingas, kai neįsivaizduojate, kiek atminties užims tam tikra struktūra.
  • Malloc () C yra dinaminė atminties paskirstymo funkcija, kuri reiškia atminties paskirstymą, kuris blokuoja atmintį su tam tikru dydžiu, kuris inicijuojamas iki šiukšlių vertės
  • „Calloc“ (C) yra gretima atminties paskirstymo funkcija, skirianti kelis atminties blokus vienu metu, inicijuojant 0
  • „Realloc“ (C) naudojama perskirstyti atmintį pagal nurodytą dydį.
  • Nemokama () funkcija naudojama dinamiškai paskirstytai atminčiai išvalyti.

Įdomios straipsniai...