Dynaaminen muistin varaus C:ssä malloc(), calloc()-funktioiden avulla

Ennen kuin opit C-dynaamisen muistin allokoinnin, ymmärrämme:

Kuinka C-muistinhallinta toimii?

Kun määrität muuttujan käyttämällä perustietotyyppiä, C-kääntäjä varaa automaattisesti muistitilan muuttujalle muistivarastossa nimeltä pino.

Esimerkiksi float-muuttuja vie tyypillisesti 4 tavua (alustan mukaan), kun se ilmoitetaan. Voimme tarkistaa nämä tiedot käyttämällä sizeof operaattori alla olevan esimerkin mukaisesti

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

Tuotos on:

 The size of float is 4 bytes

Lisäksi määritetyn kokoinen matriisi on allokoitu vierekkäisiin muistilohkoihin, jokaisella lohkolla on yhden elementin koko:

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

Tulos on:

 The size of the float array with 10 element is 40

Kuten tähän mennessä on opittu, perustietotyyppiä tai taulukkoa määritettäessä muistia hallitaan automaattisesti. C:ssä on kuitenkin muistin allokointiprosessi, jonka avulla voit toteuttaa ohjelman, jonka taulukon kokoa ei ole määritetty, kunnes suoritat ohjelman (ajoaika). Tätä prosessia kutsutaan "Dynaaminen muistin varaus"

Nyt voit luoda ja tuhota joukon elementtejä dynaamisesti ajon aikana ilman ongelmia. Yhteenvetona voidaan todeta, että automaattinen muistinhallinta käyttää pinoa ja C Dynamic Memory Allocation käyttää pinoa.

The kirjastossa on dynaamisesta muistinhallinnasta vastaavat toiminnot.

Toiminto	Tarkoitus
malloc ()	Varaa pyydetyn koon muistin ja palauttaa osoittimen ensimmäiseen tavuun varattu tila.
calloc()	Varaa tilaa taulukon elementeille. Alustaa elementit nollaan ja palauttaa osoittimen muistiin.
realloc()	Sitä käytetään muuttamaan aiemmin varatun muistitilan kokoa.
Vapaa()	Vapauttaa tai tyhjentää aiemmin varatun muistitilan.

Keskustellaan yllä olevista toiminnoista niiden sovelluksen kanssa

Malloc()-funktion syntaksi:

ptr = (cast_type *) malloc (byte_size);

Täällä

• ptr on cast_typen osoitin.
• C malloc()-funktio palauttaa osoittimen varattuun muistiin byte_size.

Esimerkki malloc():

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

Kun tämä käsky on suoritettu onnistuneesti, varataan 50 tavun muistitilaa. Varatun tilan ensimmäisen tavun osoite on osoitettu osoittimelle ptr, jonka tyyppi on int.

Harkitse toista esimerkkiä:

#include <stdlib.h>
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));
    }
}

lähtö:

Value of the 6th integer is 480

1. Huomaa, että koko(*ptr) sen sijaan käytettiin koko (int) jotta koodista tulee kestävämpi, kun *ptr-ilmoitus kirjoitetaan myöhemmin eri tietotyyppiin.
2. Varaus voi epäonnistua, jos muisti ei riitä. Tässä tapauksessa se palauttaa NULL-osoittimen. Joten sinun tulee sisällyttää koodi tarkistaaksesi NULL-osoittimen.
3. Muista, että varattu muisti on peräkkäinen ja sitä voidaan käsitellä taulukona. Voimme käyttää osoitinaritmetiikkaa taulukon elementtien käyttämiseen hakasulkeiden [ ] sijaan. Suosittelemme käyttämään + viittaamaan taulukon elementteihin, koska inkrementaatio ++ tai += muuttaa järjestelmän tallentamaa osoitetta. osoitin.

Malloc()-funktiota voidaan käyttää myös merkkitietotyypin sekä monimutkaisten tietotyyppien, kuten rakenteiden, kanssa.

Esimerkiksi:

#include <stdio.h>
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);
}

lähtö:

 Value of the 2nd integer is 50

Calloc()-funktion syntaksi:

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

• Yllä olevaa käskyä käytetään allokoimaan n samankokoista muistilohkoa.
• Kun muistitila on varattu, kaikki tavut alustetaan nollaan.
• Palautetaan osoitin, joka on tällä hetkellä varatun muistitilan ensimmäisessä tavussa.

Aina kun muistitilan varaamisessa tapahtuu virhe, kuten muistin puute, palautetaan nollaosoitin.

Esimerkki calloc():

Alla oleva ohjelma laskee aritmeettisen sekvenssin summan.

#include <stdio.h>
    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;
    }

Tulos:

Building and calculating the sequence sum of the first 10 terms
Sum = 45

calloc() vs. malloc(): Keskeiset erot

Seuraavassa on keskeinen ero malloc() vs calloc() ryhmässä C:

Calloc()-funktio on yleensä sopivampi ja tehokkaampi kuin malloc()-funktio. Vaikka molempia toimintoja käytetään varaamaan muistitilaa, calloc() voi varata useita lohkoja kerralla. Sinun ei tarvitse pyytää muistilohkoa joka kerta. Calloc()-funktiota käytetään monimutkaisissa tietorakenteissa, jotka vaativat enemmän muistitilaa.

C:n calloc():n allokoima muistilohko alustetaan aina nollaan, kun taas C:n malloc()-funktiossa se sisältää aina roskaarvon.

Realloc()-funktion syntaksi:

ptr = realloc (ptr,newsize);

Yllä oleva käsky varaa uuden muistitilan, jonka koko on määritetty muuttujassa newsize. Toiminnon suorittamisen jälkeen osoitin palautetaan muistilohkon ensimmäiseen tavuun. Uusi koko voi olla suurempi tai pienempi kuin edellinen muisti. Emme voi olla varmoja siitä, osoittaako vasta varattu lohko samaan paikkaan kuin edellinen muistilohko. Tämä toiminto kopioi kaikki aiemmat tiedot uudelle alueelle. Se varmistaa, että tiedot pysyvät turvassa.

Esimerkki realloc():

#include <stdio.h>
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 size
   strcat(ptr, " In 'C'");
   printf(" %s,  Address = %u\n", ptr, ptr);
   free(ptr);
   return 0;
}

Aina kun C:n realloc() johtaa epäonnistuneeseen toimintoon, se palauttaa nollaosoittimen ja myös edellinen data vapautetaan.

#include <stdio.h>
    int main() {
        int * arr_dynamic = NULL;
        int elements = 2, i;
        arr_dynamic = calloc(elements, sizeof(int)); //Array with 2 integer blocks
        for (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 elements
        printf("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 -ohjelman tulos näytöllä:

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

Yhteenveto

• Voimme hallita muistia dynaamisesti luomalla muistilohkoja kasaan tarpeen mukaan
• C Dynamic Memory Allocation -ohjelmassa muisti varataan ajon aikana.
• Dynaaminen muistin allokointi mahdollistaa merkkijonojen ja taulukoiden manipuloinnin, joiden koko on joustava ja jota voidaan muuttaa milloin tahansa ohjelmassasi.
• Sitä tarvitaan, kun sinulla ei ole aavistustakaan, kuinka paljon muistia tietty rakenne vie.
• Malloc() C:ssä on dynaaminen muistin allokointifunktio, joka tarkoittaa muistin varausta, joka estää tietyn kokoisen muistin, joka on alustettu roskaarvoksi
• Calloc() C:ssä on peräkkäinen muistin varausfunktio, joka varaa useita muistilohkoja kerrallaan, joka on alustettu nollaan
• Realloc() C:ssä käytetään muistin uudelleenallokointiin määritetyn koon mukaan.
• Free()-funktiota käytetään tyhjentämään dynaamisesti varattu muisti.