Calloc i c

“Bruk og tildeling av minne eller rom i et system sies å være det viktigste i ethvert programmeringsskript når du har mye data i form av variabler og matriser. C-språket er veldig dynamisk når det gjelder tildeling av minne, da det inneholder mange minnespesifikke funksjoner i det. En av disse funksjonene er Calloc (). Sammenhengende tildeling er et annet navn for "Calloc". Denne C -språkmetoden tildeler dynamisk minne for en viss type. Denne teknikken brukes til å dynamisk tildele ønsket antall minneblokker av en bestemt type.”

Denne tilnærmingen er ganske lik C -språkets Malloc -metode, men det er to forskjeller gitt nedenfor:

1. Hver blokk i denne funksjonen får en null initialisering, og en bestemt type tildeles.
2. Sammenlignet med Malloc, inneholder den to argumenter eller parametere.

Syntaks

(Cast-type*) Calloc (n, størrelse);

Vi kan kaste det returnerte minnet til enhver passende minnetype fordi denne funksjonen returnerer en tomme peker til den nødvendige adressen i minnet. For eksempel:

ptr = (int*) calloc (20, størrelse av (int));

Ovennevnte kode brukes til å tildele 20 heltalstore sammenhengende blokker med minne, som hver inneholder 20 elementer.

Eksempel 1

La oss starte med å skrive en enkel kode. I dette eksemplet bruker vi Visual Studio for å lage et tomt C -prosjekt og legge til en fil kalt som Forkexample.c i kildefiler katalog/mappe. Undersøk koden i delen nedenfor. De to første linjene i prøven nedenfor brukes til å inkludere de nødvendige overskriftsfilene. Deretter begynner hovedfunksjonen. Legg merke til bruken av (Float*) for å endre tomrommet til en floatpeker. Denne kommandoen i hovedfunksjonen tildeler sammenhengende minneplass ved å bruke Calloc -funksjonen for 25 elementer, hver av floatstørrelse.

Siden dette minnet er dynamisk, vil det bli tildelt når filen utføres; Imidlertid vil den bli utgitt etter at programmets utførelsessyklus er fullført. Den demonstrerer bare hvordan en minnetildeling kan utføres ved hjelp av Calloc -funksjonen; Ingen spesifikk utgang vil bli presentert for brukeren på skjermen siden ingen Printf -funksjon er brukt. Den betingede uttalelsen må brukes til å avgjøre om minnet er tildelt eller ikke.

#inkludere
#inkludere
int main ()
float* a = (float*) calloc (25, sizeof (float)));
retur 0;

Eksempel 2

De to første linjene i prøvekoden nedenfor inkluderer de nødvendige overskriftsfilene. Hovedmetoden starter deretter. I den første linjen i hovedfunksjonen kaster vi punktdatatypen til et heltall og bruker Calloc -funksjonen til å tildele 25 blokker med minne med en heltallstørrelse. Vi har erklært en variabel av heltallstypen i følgende linje, som vi senere vil bruke for å vise utdataene på skjermen. I den følgende setningen bruker vi IF -tilstanden for å avgjøre om Calloc -punktet returnerer en nullverdi eller ikke. Bare under disse omstendighetene, for eksempel når en tildeling mislykkes eller minneplassen ikke er tildelt, kommer nullverdien tilbake.

I den situasjonen bruker vi Printf -funksjonen for å vise meldingen “Memory Not tillatt” eller “Calloc ikke klarte å tildele minnet.”Vi viser suksessmeldingen på skjermen på en annen måte. Brukerens innspill blir samlet på neste linje og lagres i den tidligere deklarerte variabelen.

#inkludere
#inkludere
int main ()
int* peker = (int*) calloc (25, sizeof (int));
int a;
if (peker == null)
printf ("Memory ikke tildelt.\ n ");
annet
printf ("Memory vellykket tildelt ved hjelp av calloc -funksjonen.\ n ");
scanf ("%d", & a);
retur 0;

Her er skjermutgangen som viser at Calloc -metoden vellykket tildeler minnet.

La oss prøve å mislykkes denne prosedyren ved å gjøre en liten endring av koden vist ovenfor. For å gjøre dette, må vi øke størrelsen på antall elementer som krever denne størrelsen. Denne modifiserte koden endrer bare den første linjen i hovedmetoden, angir antall elementer og gir verdien 2500000000000000000 til Calloc -funksjonen.

#inkludere
#inkludere
int main ()
int* peker = (int*) calloc (25000000000000000000000, sizeof (int));
int a;
if (peker == null)
printf ("Memory ikke tildelt.\ n ");
annet
printf ("Memory vellykket tildelt ved hjelp av calloc -funksjonen.\ n ");
scanf ("%d", & a);
retur 0;

Programmet kjører vellykket når vi kjører koden, men Calloc returnerer NULL, noe som indikerer at programmet ikke kan tildele det forespurte mengden minne.

Eksempel 3

I dette eksemplet ber vi om brukerens innspill angående antall elementer som trengs for å lagre minneblokkene. De nødvendige overskriftsfilene er inkludert i de to første linjene i filen. Den primære hovedfunksjonen () starter deretter. Vi erklærte 4 heltallstypevariabler i hovedfunksjonen, hvorav den første er en pekertypevariabel som først og fremst brukes til å lagre Calloc -funksjonens utgang. Resten av variablene er enkle heltall. Kunden blir bedt om å legge inn antall elementer som minnetildeling er nødvendig for følgende linje.

For allokering av minneblokkstørrelse bruker vi størrelsesfunksjonen for å oppnå størrelsen på heltalldatatypen. Brukerens heltalltypede inngang oppnås ved bruk av SCANF-funksjonen. Utgangen fra Calloc -funksjonen blir deretter bekreftet for å avgjøre om den var vellykket eller ikke. Hvis minnetallokeringsprosessen er vellykket, returneres ikke nullverdier. Hvis resultatet blir funnet, viser vi en suksessmelding og deretter bruker en for loop for å be brukeren om sine merker på tvers av alle fag.

#inkludere
#inkludere
int main ()
int* peker;
Intelements, Marks;
int sum = 0;
printf ("Angi antall elementer (fagdata) som kreves:");
Scanf ("%d", & nelements);
peker = (int*) calloc (nelements, størrelse av (int));
if (peker == null)
printf ("Memory ikke tildelt.\ n ");
Avslutt (0);
annet
printf ("Memory vellykket tildelt ved hjelp av calloc -funksjonen.\ n ");
for (int i = 0; i < nElements; i++);
int merker = 0;

Vi vil vise brukerens samlede poengsum ved å bruke variabelen for minnefordeling. Derfor ber vi brukeren om å legge inn antall elementer eller fag som minnetildeling er nødvendig i utgangspunktet bare for det formålet. Etter at minnet er tildelt riktig, bruker vi en pekervariabel for å lagre emnemerkene. Merkene for hvert emne vises senere i for -loopen, og summen av merkene vises på slutten ved å bruke sløyfen til å kjøre sumfunksjonen.

printf ("Enter Marks of Emne (%d):", i);
scanf ("%d", & merker);
peker [i] = merker;
printf ("Studentfagene markerer \ n");
for (int i = 0; i < nElements; ++i)
printf ("emne %d - [ %d] \ n", (i+1), poinyer [i]);
sum = sum+peker [i];
printf ("Total merker: %d", sum);

SCANF ("%d%", & nelements);
retur 0;

Her er utdataene fra ovennevnte utdragekode:

Konklusjon

Denne artikkelen demonstrerer Calloc -minnefunksjonen i C ved å bruke tre forskjellige, men enkle eksempler. Eksemplene utdyper at hvis det er utilstrekkelig minneplass tilgjengelig, mislykkes denne minnetildelingen og returnerer en nullpeker, noe som indikerer at det var en fiasko via Calloc -funksjonen til C.