malloc() Funktsioon C teegis koos EXAMPLE'iga

Mis on malloc C-s?

Funktsioon malloc () tähistab mälu eraldamist. See on funktsioon, mida kasutatakse mäluploki dünaamiliseks eraldamiseks. See reserveerib määratud suurusega mäluruumi ja tagastab mälukohale osutava nullkursori. Tagastatud kursor on tavaliselt tühine. See tähendab, et saame määrata mis tahes osutile malloc funktsiooni.

Süntaks

ptr = (cast_type *) malloc (byte_size);

Siin

• ptr on cast_type kursor.
• Funktsioon malloc tagastab kursori eraldatud mälule byte_size.

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

Kui see lause on edukalt täidetud, reserveeritakse 50 baiti suurune mäluruum. Reserveeritud ruumi esimese baidi aadress määratakse int tüüpi osutile ptr.

Mõelge veel ühele malloci rakendamise näitele:

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

Väljund:

Value of the 6th integer is 480

Pane tähele, et koodi töökindlamaks muutmiseks, kui *ptr deklaratsioon hiljem teisele andmetüübile tüübimuundatakse, kasutati sizeof(int) asemel sizeof(*ptr).

Jaotamine võib ebaõnnestuda, kui mälust ei piisa. Sel juhul tagastab see NULL osuti. Seega peaksite NULL-osuti kontrollimiseks lisama koodi.

Pea meeles, et eraldatud mälu on külgnev ja seda saab käsitleda massiivina. Me saame kasutada pointer Massiivi elementide juurde pääsemiseks soovitame kasutada aritmeetikat nurksulgude [] asemel. Soovitame massiivi elementide viitamiseks kasutada +, sest inkrementeerimise ++ või += kasutamine muudab pointeri salvestatud aadressi.

Funktsiooni Malloc saab kasutada ka nii märgi andmetüübi kui ka keerukate andmetüüpidega, näiteks struktuuridega.

Miks kasutada C-s malloc() funktsiooni?

Staatilised massiivid ja tavalised muutujad fikseerivad oma suuruse programmi kompileerimise ajal, mis raiskab ruumi, kui nõue osutub väiksemaks, ja ebaõnnestub täielikult, kui see osutub suuremaks. malloc() lahendab selle probleemi, taotledes mälu käitusajal, nii et programm saab puhvri suuruse määrata täpselt vastavalt vastuvõetud andmete hulgale. See käitusaegne paindlikkus on programmi tuum. dünaamiline mälu eraldamine C-s.

Dünaamiline eraldamine malloc() abil on õige valik mitmes tavalises olukorras:

• Sisendi hulk on teadmata enne programmi käivitamist, näiteks faili või kasutaja antud loendi lugemist.
• Vaja on suuri plokke, mis piiratud pinu ületäituksid, kuna malloc() ammutab andmeid palju suuremast kuhjast.
• Andmed peavad elama kauem kui funktsioon, mis need lõi, sest heap-mälu püsib kuni see selgesõnaliselt vabastatakse.
• Struktuurid ja massiivid peavad programmi täitmise ajal kasvama või kahanema.

Kuna reserveeritud plokk antakse tagasi pointerina, saab seda funktsioonide vahel odavalt edastada ilma alusandmeid kopeerimata.

Kuidas vabastada malloc() abil eraldatud mälu

Malloc() poolt reserveeritud mälu asub heapis ja seda ei vabastata kunagi automaatselt. Kui programm eraldab pidevalt mälu ilma seda vabastamata, tarbib see aeglaselt kogu saadaolevat mälu, seda defekti nimetatakse mälulekkeks. Funktsioon free() tagastab süsteemile valmis ploki, et ruumi saaks uuesti kasutada.

Funktsioon free() võtab ühe argumendi, malloc() tagastatud pointeri, ja vabastab kogu ploki korraga:

int *ptr;
ptr = malloc(10 * sizeof(int));
if (ptr != NULL) {
    /* use the allocated memory here */
    free(ptr);   /* release the block */
    ptr = NULL;  /* avoid a dangling pointer */
}

Dünaamilise mälu ohutuks haldamiseks järgige neid reegleid:

• Kutsu free() funktsiooni välja täpselt üks kord iga eduka malloc() funktsiooni korral; sama ploki kaks korda vabastamine põhjustab defineerimata käitumist.
• Pärast vabastamist määrake pointer NULL-iks, et seda ei saaks rippuva pointerina uuesti kasutada.
• Mitte kunagi ei free() funktsiooniga teostata pointeri tagastamist, mida malloc() ei tagastanud, kaasa arvatud pointeri aritmeetika poolt nihutatud pointer.
• Enne kui kursor väljub ulatusest, sobita iga jaotus vastava väljalaskega.

Mitte ühtegiping C-keele käsitsi mäluhalduse põhidistsipliin on tasakaalustatud eraldamine ja vabastamine ning see hoiab ära nii lekked kui ka krahhid, mis on põhjustatud vabanenud mälu taaskasutamisest.

malloc() vs calloc(): Peamised erinevused

malloc() ja calloc() Mõlemad reserveerivad kuhjamälu, kuid erinevad oma argumentide ja uue ploki käsitlemise poolest. malloc() võtab ühe argumendi, baitide koguarvu, ja jätab sisu initsialiseerimata, seega hoiab plokk ettearvamatuid prügiväärtusi, kuni programm sinna kirjutab. calloc() võtab kaks argumenti, elementide arvu ja iga suuruse, ning tühjendab iga baidi enne pointeri tagastamist nulliks.

Praktilised erinevused taanduvad kolmele punktile:

• Initsialiseerimine: calloc() nullib mälu, malloc() aga mitte, mis teeb malloc() veidi kiiremaks, kui väärtused niikuinii üle kirjutatakse.
• Argumendid: kirjutad malloc(n * size), aga calloc(n, size) reserveerib sama massiivi.
• Kasutusjuhtum: vali calloc(), kui oluline on puhas, nullitud plokk, ja malloc(), kui eelistatakse kiirust ja initsialiseerimine toimub käsitsi.

Mõlemad funktsioonid deklareeritakse failis stdlib.h, mõlemad tagastavad vea korral tühise pointeri või NULL-i ning mõlemad annavad oma mälu tagasi sama free() funktsiooniga.

KKK