Dinamiskā atmiņas piešķiršana C: malloc (), calloc () funkcijās

Satura rādītājs:

Anonim

Pirms apgūstat C dinamiskās atmiņas piešķiršanu, sapratīsim:

Kā darbojas atmiņas pārvaldība C?

Deklarējot mainīgo, izmantojot pamata datu tipu, C kompilators automātiski piešķir mainīgajam atmiņas vietu atmiņas krājumā, ko sauc par kaudzīti .

Piemēram, peldošais mainīgais parasti deklarē 4 baitus (saskaņā ar platformu). Mēs varam pārbaudīt šo informāciju, izmantojot operatora sizeof, kā parādīts zemāk esošajā piemērā

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

Rezultāts būs:

 The size of float is 4 bytes

Masīvs ar noteiktu lielumu tiek piešķirts blakus esošajos atmiņas blokos, katram blokam ir viena elementa lielums:

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

Rezultāts ir:

 The size of the float array with 10 element is 40

Kā līdz šim uzzinājām, deklarējot pamatdatu tipu vai masīvu, atmiņa tiek automātiski pārvaldīta. Tomēr atmiņā C tiek piešķirts process, kas ļaus jums ieviest programmu, kurā masīva lielums nav noteikts, līdz palaižat programmu (izpildlaiku). Šo procesu sauc par " dinamisko atmiņas piešķiršanu ".

Šajā apmācībā jūs uzzināsiet

  • Kā darbojas atmiņas pārvaldība C?
  • Dinamiskā atmiņas piešķiršana C
  • C malloc () Funkcija
  • Brīvā () funkcija
  • C calloc () Funkcija
  • calloc () vs malloc (): Galvenās atšķirības
  • C realloc () Funkcija
  • Dinamiskie masīvi

Dinamiskā atmiņas piešķiršana C

Dinamiskā atmiņas piešķiršana ir manuāla piešķiršana un atmiņas atbrīvošana atbilstoši jūsu programmēšanas vajadzībām. Dinamisko atmiņu pārvalda un apkalpo rādītāji, kas norāda uz tikko piešķirto atmiņas vietu apgabalā, kuru mēs saucam par kaudzi.

Tagad bez problēmām varat izpildes laikā dinamiski izveidot un iznīcināt elementu masīvu. Rezumējot, automātiskajā atmiņas pārvaldībā tiek izmantota kaudze, bet C dinamiskās atmiņas piešķiršanā - kaudze.

bibliotēkā ir funkcijas, kas atbildīgas par dinamisko atmiņas pārvaldību.

Funkcija Mērķis
malloc () Piešķir pieprasītā lieluma atmiņu un atgriež rādītāju pie piešķirtās vietas pirmā baita.
calloc () Piešķir vietu masīva elementiem. Inicializē elementus uz nulli un atgriež rādītāju atmiņā.
realloc () To izmanto, lai modificētu iepriekš piešķirtās atmiņas vietas lielumu.
Bezmaksas () Atbrīvo vai iztukšo iepriekš piešķirto atmiņas vietu.

Apspriedīsim iepriekš minētās funkcijas ar to pielietojumu

C malloc () Funkcija

Funkcija C malloc () apzīmē atmiņas piešķiršanu. Tā ir funkcija, ko izmanto, lai dinamiski piešķirtu atmiņas bloku. Tas rezervē noteikta izmēra atmiņas vietu un atgriež nulles rādītāju, kas norāda uz atmiņas vietu. Atgrieztais rādītājs parasti ir tukšs. Tas nozīmē, ka mēs varam piešķirt C malloc () funkciju jebkuram rādītājam.

Malloka sintakse () Funkcija:

ptr = (cast_type *) malloc (byte_size);

Šeit,

  • ptr ir cast_type rādītājs.
  • Funkcija C malloc () atgriež rādītāju atvēlētajā atmiņā byte_size.

Malloc () piemērs:

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

Kad šis priekšraksts ir veiksmīgi izpildīts, tiek rezervēta 50 baitu atmiņas vieta. Rezervētās vietas pirmā baita adrese tiek piešķirta int tipa rādītājam ptr.

Apsveriet vēl vienu piemēru:

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

Izeja:

Value of the 6th integer is 480

  1. Ievērojiet, ka sizeof (* ptr) vietā tika izmantots sizeof (int) , lai padarītu kodu izturīgāku, kad vēlāk * ptr deklarācija tiek veidota citam datu tipam.
  2. Piešķirt var neizdoties, ja nepietiek atmiņas. Šajā gadījumā tas atgriež NULL rādītāju. Tātad, lai pārbaudītu NULL rādītāju, jums jāiekļauj kods.
  3. Paturiet prātā, ka piešķirtā atmiņa ir blakus, un to var uzskatīt par masīvu. Lai piekļūtu masīva elementiem, mēs varam izmantot rādītāju aritmētiku, nevis izmantot iekavas []. Mēs iesakām izmantot +, lai atsauktos uz masīva elementiem, jo, izmantojot pieaugumu ++ vai + =, tiek mainīta rādītāja saglabātā adrese.

Malloc () funkciju var izmantot arī ar rakstzīmju datu tipu, kā arī sarežģītiem datu tipiem, piemēram, struktūrām.

Brīvā () funkcija

Mainīgo atmiņa kompilēšanas laikā tiek automātiski sadalīta. Dinamiskā atmiņas piešķiršanā jums ir skaidri jānorāda atmiņa. Ja tas nav izdarīts, var rasties atmiņas kļūda.

Funkcija free () tiek izsaukta, lai atbrīvotu / sadalītu atmiņu C. Atbrīvojot atmiņu savā programmā, jūs padarāt vairāk pieejamu lietošanai vēlāk.

Piemēram:

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

Rezultāts

 Value of the 2nd integer is 50

C calloc () Funkcija

Funkcija C calloc () apzīmē blakus esošo sadalījumu. Šo funkciju izmanto, lai piešķirtu vairākus atmiņas blokus. Tā ir dinamiska atmiņas piešķiršanas funkcija, ko izmanto, lai piešķirtu atmiņu sarežģītām datu struktūrām, piemēram, masīviem un struktūrām.

Funkcija Malloc () tiek izmantota, lai piešķirtu vienu atmiņas vietas bloku, savukārt Calloc () C - vairāku atmiņas bloku piešķiršanai. Katram blokam, ko piešķir calloc () funkcija, ir vienāds lielums.

Funkcijas calloc () sintakse:

ptr = (cast_type *) calloc (n, size);
  • Iepriekš minēto paziņojumu izmanto, lai piešķirtu n vienāda lieluma atmiņas blokus.
  • Pēc atmiņas vietas piešķiršanas visi baiti tiek inicializēti līdz nullei.
  • Atgriež rādītāju, kas pašlaik atrodas atvēlētās atmiņas vietas pirmajā baitā.

Ikreiz, kad rodas kļūda, piešķirot atmiņas vietu, piemēram, atmiņas trūkumam, tiek atgriezts nulles rādītājs.

Calloc () piemērs:

Zemāk esošā programma aprēķina aritmētiskās secības summu.

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

Rezultāts:

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

calloc () vs malloc (): Galvenās atšķirības

Tālāk ir galvenā atšķirība starp malloc () Vs calloc () C:

Funkcija calloc () parasti ir piemērotāka un efektīvāka nekā malloc () funkcija. Lai gan abas funkcijas tiek izmantotas atmiņas vietas piešķiršanai, Calloc () var piešķirt vairākus blokus vienā reizē. Katru reizi nav jāpieprasa atmiņas bloks. Funkcija calloc () tiek izmantota sarežģītās datu struktūrās, kurām nepieciešama lielāka atmiņas vieta.

Atmiņas bloks, ko piešķir calloc () C, vienmēr tiek inicializēts līdz nullei, savukārt funkcija malloc () C vienmēr satur atkritumu vērtību.

C realloc () Funkcija

Izmantojot funkciju C realloc () , jau piešķirtajai atmiņai varat pievienot vairāk atmiņas. Tas paplašina pašreizējo bloku, vienlaikus atstājot sākotnējo saturu tādu, kāds tas ir. realloc () C nozīmē atmiņas pārdalīšanu.

Realloc () var izmantot arī, lai samazinātu iepriekš piešķirtās atmiņas lielumu.

Funkcijas realloc () sintakse:

ptr = realloc (ptr,newsize);

Iepriekš minētajā paziņojumā mainīgajā newsize tiek piešķirta jauna atmiņas telpa ar noteiktu izmēru. Pēc funkcijas izpildes rādītājs tiks atgriezts atmiņas bloka pirmajā baitā. Jaunais izmērs var būt lielāks vai mazāks par iepriekšējo atmiņu. Mēs nevaram būt pārliecināti, vai tikko piešķirtais bloks norādīs uz to pašu vietu, kur iepriekšējā atmiņas bloks. Šī funkcija nokopēs visus iepriekšējos datus jaunajā reģionā. Tas nodrošina, ka dati paliks droši.

Realloc () piemērs:

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

Ikreiz, kad realloc () C rezultātā notiek neveiksmīga darbība, tas atgriež nulles rādītāju, un tiek atbrīvoti arī iepriekšējie dati.

Dinamiskie bloki C.

Dinamiskais masīvs C ļauj elementu skaitam pēc vajadzības pieaugt. C Dinamisko masīvu plaši izmanto datorzinātņu algoritmos.

Nākamajā programmā mēs esam izveidojuši un mainījuši dinamiskā masīva lielumu C

#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 masīvu programmas rezultāts ekrānā:

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

Kopsavilkums

  • Mēs varam dinamiski pārvaldīt atmiņu, pēc vajadzības izveidojot atmiņas blokus kaudzē
  • C dinamiskās atmiņas piešķiršanā atmiņa tiek piešķirta darbības laikā.
  • Dinamiskā atmiņas piešķiršana ļauj manipulēt ar virknēm un masīviem, kuru lielums ir elastīgs un kurus jebkurā laikā var mainīt jūsu programmā.
  • Tas ir nepieciešams, ja jums nav ne jausmas, cik daudz atmiņas aizņems konkrētā struktūra.
  • Malloc () C ir dinamiska atmiņas piešķiršanas funkcija, kas nozīmē atmiņas piešķiršanu, kas bloķē atmiņu ar noteiktu izmēru, kas inicializēts atkritumu vērtībā
  • Calloc () C ir blakusesoša atmiņas piešķiršanas funkcija, kas vienā reizē piešķir vairākus atmiņas blokus, kas inicializēti uz 0
  • Realloc () C tiek izmantots, lai pārdalītu atmiņu atbilstoši norādītajam izmēram.
  • Funkcija Free () tiek izmantota, lai notīrītu dinamiski piešķirto atmiņu.