Forskjellen mellom malloc() og calloc()

by: Benjamin rullator Benjamin rullator
Hours oppdatert

Nøkkelforskjeller mellom malloc() og calloc()

  • malloc()-funksjonen returnerer bare startadressen og gjør den ikke null, på den annen side returnerer calloc()-funksjonen startadressen og gjør den null.
  • I malloc-funksjonen er antallet argumenter 1, mens i calloc-funksjonen er antallet argumenter 2.
  • malloc() tidseffektivitet er høyere enn calloc(), mens malloc() ikke er sikker sammenlignet med calloc()
  • malloc initialiserer ikke minne, mens calloc utfører minneinitialisering.
malloc() vs calloc()
malloc() vs calloc()

Hva er dynamisk minnetildeling?

Dynamisk minnetildeling er en prosess for å tildele minne under kjøring. Det er fire biblioteksrutiner, calloc(), free(), realloc(), og malloc() som kan brukes til å allokere minne og frigjøre det under programkjøringen. Disse rutinene er definert i header-filen kalt stdlib.h.

Hva er malloc()?

Det er en funksjon som brukes til å tildele en minneblokk dynamisk. Den reserverer minneplass av spesifisert størrelse og returnerer null-pekeren som peker til minneplasseringen.

Pekeren som returneres er vanligvis av typen void. Det betyr at vi kan tilordne malloc-funksjon til enhver peker. Den fulle formen for malloc er minnetildeling.

Hva er calloc()?

Calloc() funksjon brukes til å tildele flere minneblokker. Det er en dynamisk minneallokeringsfunksjon som brukes til å allokere minnet til komplekse datastrukturer som matriser og strukturer. Hvis denne funksjonen ikke klarer å tildele nok plass som spesifisert, returnerer den null-pekeren. Den fullstendige formen for calloc-funksjonen er sammenhengende tildeling.

RELATERTE ARTIKLER

Forskjellen mellom malloc() og calloc()

Her er viktige forskjeller mellom malloc() vs calloc():

malloc () calloc()
Malloc()-funksjonen vil lage en enkelt minneblokk med størrelse spesifisert av brukeren. Calloc()-funksjonen kan tilordne flere minneblokker for en variabel.
Malloc-funksjonen inneholder søppelverdi. Minneblokken tildelt av en calloc-funksjon initialiseres alltid til null.
Antall argument er 1. Antall argumenter er 2.
Calloc er tregere enn malloc. Malloc er raskere enn calloc.
Det er ikke sikkert sammenlignet med calloc. Den er sikker å bruke sammenlignet med malloc.
Tidseffektiviteten er høyere enn calloc(). Tidseffektiviteten er lavere enn malloc().
Malloc()-funksjonen returnerer bare startadressen og gjør den ikke null. Før du tildeler adressen, returnerer Calloc()-funksjonen startadressen og gjør den null.
Den utfører ikke initialisering av minne. Den utfører minneinitialisering.

Syntaks for malloc()

Her er en syntaks for malloc()

ptr = (cast_type *) malloc (byte_size);

I syntaksen ovenfor er ptr en peker av cast_type. Malloc-funksjonen returnerer en peker til det tildelte minnet til byte_size.

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

Når denne setningen er utført, er en minneplass på 50 byte reservert. Adressen til den første byten med reservert plass er tilordnet pekeren "ptr" av typen int.

Syntaks for calloc()

Her er en syntaks for malloc()

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

Syntaksen ovenfor brukes til å tildele n minneblokker av samme størrelse. Etter at minneplassen er tildelt, initialiseres alle byte til null. Pekeren, som for øyeblikket er på den første byten av den tildelte minneplassen, returneres.

Eksempel på malloc() i C

I koden nedenfor brukes sizeof(*ptr) for å tildele en minneblokk på 15 heltall. I printf-setningen finner vi verdien av det 6. heltall.

#include<stdlib.h>
#include<stdio.h>
int main(){
int *ptr;
ptr = malloc(15 * sizeof(*ptr)); 
    if (ptr != NULL) {
      *(ptr + 5) = 480; 
      printf("Value of the 6th integer is %d",*(ptr + 5));
    }
}

Utgang:

Verdien av det sjette heltall er 6

Eksempel på calloc() i C

C-språkprogrammet nedenfor beregner summen av de ti første leddene. Hvis pekerverdien er null, vil ikke minneplassen tildeles.

For loop brukes til å iterere verdien av en variabel "i" og skrive ut summen. Til slutt brukes funksjon fri for å frigjøre pekeren.

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

Utgang:

Bygge og beregne sekvenssummen av de første 10 leddene n Sum = 45

Hvorfor bruke malloc() ?

Her er grunnene til å bruke malloc()

  • Du bør bruke malloc() når du må tildele minne under kjøring.
  • Du bør bruke malloc når du må tildele objekter som må eksistere utover kjøringen av gjeldende minneblokk.
  • Gå for malloc() hvis du trenger å tildele minne større enn størrelsen på den stabelen.
  • Den returnerer pekeren til den første byten med tildelt plass.
  • Det gjør det mulig for utviklere å tildele minne etter behov i den nøyaktige mengden.
  • Denne funksjonen tildeler en minneblokkstørrelse på byte fra heapen.

Hvorfor bruke calloc() ?

Her er grunnene til å bruke calloc()

  • Når du må sette tildelt minne til null.
  • Du kan bruke calloc som returnerer en peker for å få tilgang til minnehaugen.
  • Brukes når du trenger å initialisere elementene til null for å returnere en peker til minnet.
  • For å forhindre overløp som er mulig med malloc()
  • Bruk calloc() for å be om en side som er kjent for å allerede være nullstilt.

Oppsummer dette innlegget med: