Alocarea dinamică a memoriei în funcții C: malloc (), calloc ()

Înainte de a învăța alocarea memoriei dinamice C, să înțelegem:

Cum funcționează Managementul memoriei în C?

Când declarați o variabilă utilizând un tip de date de bază, compilatorul C alocă automat spațiu de memorie pentru variabilă într-un pool de memorie numit stivă .

De exemplu, o variabilă plutitoare ia de obicei 4 octeți (în funcție de platformă) atunci când este declarată. Putem verifica aceste informații folosind operatorul sizeof așa cum se arată în exemplul de mai jos

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

Ieșirea va fi:

 The size of float is 4 bytes 

De asemenea, o matrice cu o dimensiune specificată este alocată în blocuri adiacente de memorie, fiecare bloc are dimensiunea pentru un element:

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

Rezultatul este:

 The size of the float array with 10 element is 40

După cum s-a învățat până acum, atunci când se declară un tip de date de bază sau o matrice, memoria este gestionată automat. Cu toate acestea, există un proces de alocare a memoriei în C, care vă va permite să implementați un program în care dimensiunea matricei este indecisă până când rulați programul (runtime). Acest proces se numește „ Alocare dinamică a memoriei ”.

În acest tutorial, veți învăța-

• Cum funcționează Managementul memoriei în C?
• Alocarea dinamică a memoriei în C
• C malloc () Funcție
• Funcția free ()
• C calloc () Funcție
• calloc () vs. malloc (): Diferențe cheie
• C realloc () Funcție
• Matrice dinamice

Alocarea dinamică a memoriei în C

Alocarea dinamică a memoriei este alocarea manuală și eliberarea memoriei în funcție de nevoile dvs. de programare. Memoria dinamică este gestionată și servită cu indicatori care indică spațiul de memorie nou alocat într-o zonă pe care o numim heap.

Acum puteți crea și distruge dinamic o serie de elemente în timpul rulării fără probleme. Pentru a rezuma, gestionarea automată a memoriei utilizează stiva, iar C Dynamic Memory Allocation utilizează heap-ul.

Biblioteca are funcții responsabile pentru gestionarea dinamică a memoriei.

Funcţie	Scop
malloc ()	Alocă memoria de dimensiunea solicitată și returnează indicatorul la primul octet de spațiu alocat.
calloc ()	Alocă spațiul pentru elementele unui tablou. Inițializează elementele la zero și returnează un pointer în memorie.
realloc ()	Este folosit pentru a modifica dimensiunea spațiului de memorie alocat anterior.
Gratuit()	Eliberează sau goleste spațiul de memorie alocat anterior.

Să discutăm funcțiile de mai sus cu aplicația lor

C malloc () Funcție

Funcția C malloc () reprezintă alocarea memoriei. Este o funcție care este utilizată pentru a aloca dinamic un bloc de memorie. Rezervă spațiu de memorie de dimensiunea specificată și returnează indicatorul nul care indică locația memoriei. Pointerul returnat este de obicei de tip nul. Înseamnă că putem atribui funcția C malloc () oricărui pointer.

Sintaxa funcției malloc ():

ptr = (cast_type *) malloc (byte_size);

Aici,

• ptr este un indicator al cast_type.
• Funcția C malloc () returnează un pointer la memoria alocată de byte_size.

Exemplu de malloc ():

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

Când această instrucțiune este executată cu succes, este rezervat un spațiu de memorie de 50 de octeți. Adresa primului octet de spațiu rezervat este atribuită indicatorului ptr de tip int.

Luați în considerare un alt exemplu:

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

Ieșire:

Value of the 6th integer is 480

1. Observați că sizeof (* ptr) a fost folosit în loc de sizeof (int) pentru a face codul mai robust atunci când declarația * ptr este tipărită mai târziu la un alt tip de date.
2. Alocarea poate eșua dacă memoria nu este suficientă. În acest caz, returnează un pointer NULL. Deci, ar trebui să includeți cod pentru a verifica dacă există un pointer NULL.
3. Rețineți că memoria alocată este contiguă și poate fi tratată ca o matrice. Putem folosi aritmetica pointerului pentru a accesa elementele matricei, mai degrabă decât folosind paranteze []. Vă sfătuim să utilizați + pentru a face referire la elementele matricei, deoarece utilizarea incrementării ++ sau + = modifică adresa stocată de pointer.

Funcția Malloc () poate fi, de asemenea, utilizată cu tipul de date de caractere, precum și cu tipuri de date complexe, cum ar fi structurile.

Funcția free ()

Memoria pentru variabile este repartizată automat la compilare. În alocarea dinamică a memoriei, trebuie să alocați în mod explicit memoria. Dacă nu se face, este posibil să întâlniți erori de memorie.

Funcția free () este chemată să elibereze / să repartizeze memoria în C. Eliberând memoria din programul dvs., faceți mai multe disponibile pentru utilizare ulterior.

De exemplu:

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

Ieșire

 Value of the 2nd integer is 50

C calloc () Funcție

Funcția C calloc () reprezintă alocarea contiguă. Această funcție este utilizată pentru a aloca mai multe blocuri de memorie. Este o funcție de alocare a memoriei dinamice care este utilizată pentru a aloca memoria structurilor de date complexe, cum ar fi matrici și structuri.

Funcția Malloc () este utilizată pentru a aloca un singur bloc de spațiu de memorie în timp ce calloc () în C este utilizat pentru a aloca mai multe blocuri de spațiu de memorie. Fiecare bloc alocat de funcția calloc () are aceeași dimensiune.

Sintaxa funcției calloc ():

ptr = (cast_type *) calloc (n, size);

• Instrucțiunea de mai sus este utilizată pentru a aloca n blocuri de memorie de aceeași dimensiune.
• După ce spațiul de memorie este alocat, atunci toți octeții sunt inițializați la zero.
• Pointerul care este în prezent la primul octet al spațiului de memorie alocat este returnat.

Ori de câte ori există o eroare la alocarea spațiului de memorie, cum ar fi lipsa de memorie, atunci se returnează un indicator nul.

Exemplu de calloc ():

Programul de mai jos calculează suma unei secvențe aritmetice.

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

Rezultat:

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

calloc () vs. malloc (): Diferențe cheie

Următoarea este diferența cheie între malloc () Vs calloc () în C:

Funcția calloc () este, în general, mai potrivită și mai eficientă decât cea a funcției malloc (). În timp ce ambele funcții sunt folosite pentru a aloca spațiu de memorie, calloc () poate aloca mai multe blocuri simultan. Nu trebuie să solicitați de fiecare dată un bloc de memorie. Funcția calloc () este utilizată în structuri de date complexe care necesită spațiu de memorie mai mare.

Blocul de memorie alocat de un calloc () în C este inițializat la zero în timp ce în funcția malloc () în C, conține întotdeauna o valoare de gunoi.

C realloc () Funcție

Folosind funcția C realloc () , puteți adăuga mai multe dimensiuni de memorie la memoria deja alocată. Extinde blocul curent lăsând conținutul original așa cum este. realloc () în C reprezintă realocarea memoriei.

realloc () poate fi, de asemenea, utilizat pentru a reduce dimensiunea memoriei alocate anterior.

Sintaxa funcției realloc ():

ptr = realloc (ptr,newsize);

Instrucțiunea de mai sus alocă un nou spațiu de memorie cu o dimensiune specificată în variabila newsize. După executarea funcției, indicatorul va fi returnat la primul octet al blocului de memorie. Noua dimensiune poate fi mai mare sau mai mică decât memoria anterioară. Nu putem fi siguri că, dacă blocul nou alocat va indica aceeași locație ca cea a blocului de memorie anterior. Această funcție va copia toate datele anterioare din noua regiune. Se asigură că datele vor rămâne în siguranță.

Exemplu de realloc ():

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

Ori de câte ori reallocul () din C are ca rezultat o operație nereușită, acesta returnează un pointer nul, iar datele anterioare sunt, de asemenea, eliberate.

Matrice dinamice în C

O matrice dinamică în C permite creșterea numărului de elemente după cum este necesar. C Matrice dinamice sunt utilizate pe scară largă în algoritmii de informatică.

În următorul program, am creat și redimensionat o matrice dinamică în 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);} 

Rezultatul programului matrice C dinamic pe ecran:

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

rezumat

• Putem gestiona dinamic memoria creând blocuri de memorie, după cum este necesar în heap
• În Alocarea dinamică a memoriei C, memoria este alocată la un timp de execuție.
• Alocarea dinamică a memoriei permite manipularea șirurilor și matricelor a căror dimensiune este flexibilă și poate fi modificată oricând în programul dvs.
• Este necesar atunci când nu aveți idee cât de multă memorie va ocupa o anumită structură.
• Malloc () în C este o funcție de alocare dinamică a memoriei care reprezintă alocarea memoriei care blochează memoria cu dimensiunea specifică inițializată la o valoare de gunoi
• Calloc () în C este o funcție de alocare de memorie contiguă care alocă mai multe blocuri de memorie la un moment inițializat la 0
• Realloc () în C este utilizat pentru a realoca memoria în funcție de dimensiunea specificată.
• Funcția Free () este utilizată pentru a șterge memoria alocată dinamic.